Java动态代理总结

概念介绍

静态代理
由程序员主动创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。

动态代理
代理类在程序运行前并不存在，在程序运行时动态生成（无需手工编写代理类源码）
实现原理：Java反射机制

实现原理

Java编译器编译好Java文件之后，产生.class 文件在磁盘中。这种class文件是二进制文件，内容是只有JVM虚拟机能够识别的机器码。JVM虚拟机读取字节码文件，取出二进制数据，加载到内存中，解析.class 文件内的信息，生成对应的 Class对象:

.class文件加载过程

由于JVM通过字节码的二进制信息加载类的，那么，如果我们在运行期系统中，遵循Java编译系统组织.class文件的格式和结构，生成相应的二进制数据，然后再把这个二进制数据加载转换成对应的类，这样，就完成了在代码中，动态创建一个类的能力了。

动态创建类

具体实现

• 接口TargetInterface

public interface TargetInterface {
    public int targetMethodA(int number);  
    public int targetMethodB(int number);
}

• 具体实现类ConcreteClass

public class ConcreteClass implements TargetInterface {

    @Override
    public int targetMethodA(int number) {
        System.out.println("开始调用目标类的方法targetMethodA...");  
        System.out.println("操作-打印数字:"+number);  
        System.out.println("结束调用目标类的方法targetMethodA...");  
        return number;  
    }

    @Override
    public int targetMethodB(int number) {
        System.out.println("开始调用目标类的方法targetMethodB...");  
        System.out.println("操作-打印数字:"+number);  
        System.out.println("结束调用目标类的方法targetMethodB...");  
        return number;  
    }

}

• 动态代理类ProxyHandler
  调用代理类目标接口方法时，对自动将其转发到代理处理器中的invoke()方法中，invoke()方法内部可以实现预处理，对委托类方法调用，后续处理等逻辑。

public class ProxyHandler implements InvocationHandler {

    private Object concreteClass;  
    
    public ProxyHandler(Object concreteClass){  
        this.concreteClass=concreteClass;  
    }  
    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        System.out.println("proxy:"+proxy.getClass().getName());  
        System.out.println("method:"+method.getName());  
        System.out.println("args:"+args[0].getClass().getName());  
          
        System.out.println("Before invoke method...");  
        Object object=method.invoke(concreteClass, args);//普通的Java反射代码,通过反射执行某个类的某方法  
        //System.out.println(((ConcreteClass)concreteClass).targetMethod(10)+(Integer)args[0]);  
        System.out.println("After invoke method...");  
        return object;  
    }  

}

• 测试类DynamicProxyExample

public class DynamicProxyExample {
    public static void main(String[] args){  
        ConcreteClass c=new ConcreteClass();//元对象(被代理对象)  
        InvocationHandler ih=new ProxyHandler(c);//代理实例的调用处理程序。  
        //创建一个实现业务接口的代理类,用于访问业务类(见代理模式)。  
        //返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序，如ProxyHandler。  
        TargetInterface targetInterface=  
            (TargetInterface)Proxy.newProxyInstance(c.getClass().getClassLoader(),c.getClass().getInterfaces(),ih);  
        //调用代理类方法,Java执行InvocationHandler接口的方法.  
        int i=targetInterface.targetMethodA(5);  
        System.out.println(i);  
        System.out.println();  
        int j=targetInterface.targetMethodB(15);  
        System.out.println(j);  
   }  
}

优点

1. 减少编程的工作量：假如需要实现多种代理处理逻辑，只要写多个代理处理器就可以了，无需每种方式都写一个代理类。
2. 系统扩展性和维护性增强，程序修改起来也方便多了(一般只要改代理处理器类就行了)。

不足

目前根据GOF的代理模式，代理类和委托类需要都实现同一个接口(在代理类实例化时需传入目标接口)。也就是说只有实现了某个接口的类可以使用Java动态代理机制。但是，事实上使用中并不是遇到的所有类都会给你实现一个接口。因此，对于没有实现接口的类，目前无法使用该机制。

参考资料

[1]Java动态代理机制详解（JDK 和CGLIB，Javassist，ASM）
[2]Java动态代理详解