静态代理、JDK动态代理、CGLIB动态代理

静态代理

静态代理是代理模式的实现方式之一，是相对于动态代理而言的。所谓静态代理是指，在程序运行前，由程序员创建或特定工具自动生成源代码并对其编译生成.class文件。

静态代理的实现只需要三步：首先，定义业务接口；其次，实现业务接口；然后，定义代理类并实现业务接口；最后便可通过客户端进行调用。

/**
 * 代理接口
 */
public interface DemoService {

    public void print(String param);
    
}

/**
 * 真正的实现类
 */
public class DemoServiceImpl implements DemoService {

    @Override
    public void print(String param) {
        System.out.println("real method:" + param);
    }

}

/**
 * 代理类
 */
public class DemoProxy implements DemoService {

    private DemoService demoService;
    
    public DemoProxy(DemoServiceImpl impl) {
        this.demoService = impl;
    }
    
    @Override
    public void print(String param) {
        System.out.println("before real method");
        demoService.print("AAA");
        System.out.println("after real method");
    }

}

//测试类
public class Test {

    public static void main(String[] args) {
        DemoService demoService = new DemoProxy(new DemoServiceImpl());
        demoService.print("AAA");
    }

}

image.png

静态代理的局限性：
一个代理类Proxy只能服务Subject一种接口，如果有10个不同类型的对象，需要创建10个代理类，类的数量激增、也增加了代码的冗余

如果只用一个代理类，就能完成全部的代理功能就好了，于是就有了动态代理

动态代理

和静态代理不同，动态代理的字节码是在程序运行期间，由JVM根据反射等机制动态生成的。代理类和实际类的关系是在程序运行时确定的，依托反射等机制，动态代理可以动态生成任意类型的代理类，一个代理的处理程序就可以处理多种对象。

java中的动态代理有两种，一种是java自带的jdk动态代理，一种是基于cglib的动态代理

JDK动态代理

（1）Proxy 类提供了用于创建动态代理类和实例对象的方法，它是所创建的动态代理类的父类
（2）InvocationHandler 接口是代理处理程序类的实现接口，每一个被生成的代理类实例都可以提供一个相关的代理处理程序类，代理类实例的方法被调用时会回调invoke()方法

public interface DemoService {
    
    public String print(String param);
    
}

public class DemoServiceImpl implements DemoService {

    @Override
    public String print(String param) {
        System.out.println("REAL Method");
        return param + "  REAL METHOD";
    }

}

public class ProxyHandler implements InvocationHandler {

    private Object obj;
    
    public ProxyHandler(Object obj) {
        this.obj = obj;
    }
    
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before Real Method");
        String print = (String)method.invoke(obj, args);
        System.out.println("after Real Method");
        return print;
    }

}

public class Test {
    public static void main(String[] args) {
        DemoServiceImpl impl = new DemoServiceImpl();
        ProxyHandler handler = new ProxyHandler(impl);
        DemoService demo = (DemoService) Proxy.newProxyInstance(impl.getClass().getClassLoader(), 
                impl.getClass().getInterfaces(), handler);
        demo.print("AAAA");
        
    }
}

image.png

JDK动态代理的局限性：如果是抽象类或者一般的类需要进行代理，jdk动态代理就无法满足了，只有使用cglib动态代理

cglib动态代理

主要用到import net.sf.cglib.proxy包下的MethodInterceptor、MethodProxy和Enhancer类

(1)、MethodInterceptor
MethodInterceptor类是方法拦截器，代理类实例的方法被调用时会回调MethodInterceptor的intercept()方法拦截，用来实现自己的代理逻辑，类似于jdk动态代理的InvocationHandler接口

(2)、MethodProxy
MethodProxy是intercept()方法中的第四个参数的类型，它是实际类方法的代理引用，使用methodProxy比使用jdk自身的method在效率上会有提升

(3)、Enhancer
Enhancer用来动态创建实际类子类的代理类实例，setSuperclass()方法设置实际类为父类，setCallback()方法建立方法回调，create()方法创建一个代理类实例

public class RealDemo {

    public void print(String param) {
        System.out.println("REAL METHOD " + param);
    }
    
}

    public Object newInstance(Object target) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
    
    @Override
    public Object intercept(Object arg0, Method mrthod, Object[] arg2, MethodProxy proxy) throws Throwable {
        System.out.println("BEFORE......");
        Object object = proxy.invokeSuper(arg0, arg2);
        System.out.println("AFTER......");
        return object;
    }

}

public class Test {

    public static void main(String[] args) {
        RealDemo demo = new RealDemo();
        ProxyIntercept intercept  = new ProxyIntercept();
        RealDemo proxyDemo = (RealDemo) intercept.newInstance(demo);
        proxyDemo.print("AAA");
    }

}

jdk动态代理是由java内部的反射机制生成一个实现代理接口的匿名类，被代理的类必须要实现一个接口，如果某个类没有实现接口则不能生成代理对象，实际使用中会有一些局限性

cglib动态代理底层是借助asm来实现的，加载实际类的.class文件，修改其字节码生成子类来处理，比java反射效率要高一些，不过生成子类的方式也带来小问题：目标类不能声明成final，因为final类不能被继承，无法生成代理；目标方法也不能声明成final，final方法不能被重写，无法得到处理

参考：https://blog.csdn.net/justloveyou_/article/details/79407248
https://www.cnblogs.com/ctxsdhy/p/5815492.html