java动态代理实现

1、先看看与动态代理紧密关联的Java API。
1）java.lang.reflect.Proxy
这是 Java 动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。
Proxy类的静态方法

Java代码  

1. // 方法 1: 该方法用于获取指定代理对象所关联的调用处理器  

2. static InvocationHandler getInvocationHandler(Object proxy)   

3.   

4. // 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象  

5. static Class getProxyClass(ClassLoader loader, Class[] interfaces)   

6.  

7. // 方法 3：该方法用于判断指定类对象是否是一个动态代理类  

8. static boolean isProxyClass(Class cl)   

9.   

10. // 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例  

11. static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)  
    

2）java.lang.reflect.InvocationHandler
这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。每次生成动态代理类对象时都要指定一个对应的调用处理器对象。
InvocationHandler的核心方法

Java代码  

1. // 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象  

2. // 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行  

3. Object invoke(Object proxy, Method method, Object[] args)  
   

3）java.lang.ClassLoader
这是类装载器类，负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。
每次生成动态代理类对象时都需要指定一个类装载器对象

2、动态代理实现步骤
具体步骤是：
a. 实现InvocationHandler接口创建自己的调用处理器
b. 给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类
c. 以调用处理器类型为参数，利用反射机制得到动态代理类的构造函数
d. 以调用处理器对象为参数，利用动态代理类的构造函数创建动态代理类对象
分步骤实现动态代理

Java代码  

1. // InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发  

2. // 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用  

3. InvocationHandler handler = new InvocationHandlerImpl(..);   

4.   

5. // 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象  

6. Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... });   

7.   

8. // 通过反射从生成的类对象获得构造函数对象  

9. Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });   

10.   

11. // 通过构造函数对象创建动态代理类实例  

12. Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });   

Proxy类的静态方法newProxyInstance对上面具体步骤的后三步做了封装，简化了动态代理对象的获取过程。
简化后的动态代理实现

Java代码  

1. // InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发  

2. InvocationHandler handler = new InvocationHandlerImpl(..);   

3.   

4. // 通过 Proxy 直接创建动态代理类实例  

5. Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,   

6.      new Class[] { Interface.class },  handler );   

3、动态代理实现示例
创建自己的调用处理器

Java代码  

1. /** 

2.  * 动态代理类对应的调用处理程序类 

3.  */  

4. public class SubjectInvocationHandler implements InvocationHandler {  

5.    

6.  //代理类持有一个委托类的对象引用  

7.  private Object delegate;  

8.    

9.  public SubjectInvocationHandler(Object delegate) {  

10.   this.delegate = delegate;  

11.  }  

12.    

13.  @Override  

14.  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  

15.   long stime = System.currentTimeMillis();   

16.   //利用反射机制将请求分派给委托类处理。Method的invoke返回Object对象作为方法执行结果。  

17.   //因为示例程序没有返回值，所以这里忽略了返回值处理  

18.   method.invoke(delegate, args);  

19.   long ftime = System.currentTimeMillis();   

20.   System.out.println("执行任务耗时"+(ftime - stime)+"毫秒");  

21.     

22.   return null;  

23.  }  

24. }   

生成动态代理对象的工厂，工厂方法列出了如何生成动态代理类对象的步骤。

Java代码  

1. /** 

2.  * 生成动态代理对象的工厂. 

3.  */  

4. public class DynProxyFactory {  

5.  //客户类调用此工厂方法获得代理对象。  

6.  //对客户类来说，其并不知道返回的是代理类对象还是委托类对象。  

7.  public static Subject getInstance(){   

8.   Subject delegate = new RealSubject();  

9.   InvocationHandler handler = new SubjectInvocationHandler(delegate);  

10.   Subject proxy = null;  

11.   proxy = (Subject)Proxy.newProxyInstance(  

12.     delegate.getClass().getClassLoader(),   

13.     delegate.getClass().getInterfaces(),   

14.     handler);  

15.   return proxy;  

16.  }  

17. }  

动态代理客户类

Java代码  

1. public class Client {  

2.   

3.  public static void main(String[] args) {  

4.   

5.   Subject proxy = DynProxyFactory.getInstance();  

6.   proxy.dealTask("DBQueryTask");  

7.  }   

8.   

9. }