Java反射学习总结四（动态代理使用实例和内部原理解析）

通过上一篇文章介绍的静态代理Java反射学习总结三（静态代理）中，大家可以发现在静态代理中每一个代理类只能为一个接口服务，这样一来必然会产生过多的代理，而且对于每个实例，如果需要添加不同代理就要去添加相应的代理类。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能或者说去动态的生成这个代理类，那么此时就必须使用动态代理完成。

动态代理知识点：

Java动态代理类位于java.lang.reflect包下，主要有以下一个接口和一个类：

1.InvocationHandler接口：    该接口中仅有一个方法

public object invoke(Object obj, Method method, Object[] args)

在实际使用时，obj一般是指代理类，method是被代理的方法，args为该方法的参数数组。这个抽象的invoke方法在代理类中动态实现。

2.Proxy类：  该类即为动态代理类，这里只介绍一下newProxyInstance()这个方法

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

这个方法是最主要的方法，它会返回代理类的一个实例，返回后的代理类可以当做被代理类使用

实现动态代理需4步骤：

1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法。

2.通过Proxy的静态方法newProxyInstance创建一个代理

3.创建被代理的类以及接口

4.通过代理调用方法

下面看这个例子具体说明如何通过上面的4个步骤来建立一个动态代理：

步骤1和步骤2合并写在一个类中，命名为DynamicProxy

[java] view plain copy print?

1. public class DynamicProxy implements InvocationHandler {  
2.   
3.     // 需要被代理类的引用  
4.     private Object object;  
5.   
6.     // 通过构造方法传入引用  
7.     public DynamicProxy(Object object) {  
8.         this.object = object;  
9.     }  
10.   
11.     // 定义一个工厂类，去生成动态代理  
12.     public Object getProxy() {  
13.         // 通过Proxy类的newProxyInstance方法动态的生成一个动态代理，并返回它  
14.         return Proxy.newProxyInstance(object.getClass().getClassLoader(), object  
15.                 .getClass().getInterfaces(), this);  
16.     }  
17.   
18.     // 重写的invoke方法，这里处理真正的方法调用  
19.     @Override  
20.     public Object invoke(Object obj, Method method, Object[] args)  
21.             throws Throwable {  
22.           
23.         beforeDoing();  
24.           
25.         Object invoke = method.invoke(object, args);  
26.           
27.         afterDoing();  
28.           
29.         return invoke;  
30.     }  
31.       
32.     public void beforeDoing() {  
33.         System.out.println("before ............");  
34.     }  
35.       
36.     public void afterDoing() {  
37.         System.out.println("after ............."+"\n");  
38.     }  
39.   
40. }  

该类实现了InvocationHandler接口，并且自定义了一个getProxy()方法去调用Proxy类的newProxyInstance()去生成一个动态代理。

步骤3：创建被代理的类以及接口

[java] view plain copy print?

1. //真实角色对象，继承自抽象角色，重写定义的方法。  
2. public class RealSubject implements Subject1,Subject2{  
3.   
4.     //Subject1接口中的方法  
5.     @Override  
6.     public void request() {  
7.         System.out.println("this is real subject");  
8.     }  
9.   
10.     //Subject1接口中的方法  
11.     @Override  
12.     public void ask() {  
13.         System.out.println("this is real ask");  
14.           
15.     }  
16.       
17.     //Subject2接口中的方法  
18.     @Override  
19.     public void request2() {  
20.         System.out.println("this is real subject2");  
21.           
22.     }  
23. }  

这个类就是我们需要被代理的类，他继承了两个接口分别是Subject1,Subject2

[java] view plain copy print?

1. interface Subject1 {  
2.       
3.     public  void request();  
4.       
5.     public void ask();  
6. }  

[java] view plain copy print?

1. interface Subject2 {  
2.       
3.     public  void request2();  
4. }  

4.通过代理调用方法

接下来在main方法中通过动态生成的代理来调用方法

[java] view plain copy print?

1. public static void main(String[] args) {  
2.           
3.         //需要被代理的类  
4.         RealSubject realSubject = new RealSubject();  
5.         //用于创建动态代理的类，将被代理类的引用传递进去  
6.         DynamicProxy dynamicProxy = new DynamicProxy(realSubject);  
7.           
8.         //通过getProxy方法动态的获取代理类，转换成需要调用的接口类型后调用方法  
9.         Subject1 s1 = (Subject1) dynamicProxy.getProxy();  
10.         s1.request();  
11.         s1.ask();  
12.           
13.         //通过getProxy方法动态的获取代理类，转换成需要调用的接口类型后调用方法  
14.         Subject2 s2 = (Subject2) dynamicProxy.getProxy();  
15.         s2.request2();  
16.     }  

最后打印：

before ............
this is real subject
after .............

before ............
this is real ask
after .............

before ............
this is real subject2
after .............

简单介绍动态代理内部实现原理：

例子看完了，肯定有如下疑问：

动态代理在哪里应用了反射机制？仅仅通过一个InvocationHandler接口和一个Proxy类的newProxyInstance方法是如何动态的生成代理？

下面就来简单的分析一下InvocationHandler，和Proxy的newProxyInstance方法是如何在运行时动态的生成代理的：

以下代码都是伪代码而且内容大部分参考马士兵动态代理的视频。如果感兴趣，建议找视频去学。

先看newProxyInstance是如何定义的

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

这里需要传入3个参数。先看第二个参数，传入一个接口类型的Class数组。

上面例子中传入的参数是object.getClass().getInterfaces()

object是被代理对象，这个参数就是通过反射拿到被代理对象的所有接口

在上面例子中就是我们定义的Subject1，Subject2接口了

有了接口数组，就可以通过类似下面的代码使用反射拿到接口中的所有方法

[java] view plain copy print?

1. for (interface infce : interfaces[]) {  
2.     Method[] methods = infce.getMethods();  
3.     for (Method m : method) {  
4.         m.getName();  
5.     }  
6. }  

在正常情况下，知道了被代理的接口和接口里面的方法就可以去生成代理类了。

大概就是下面这种的一个简单的实现：一个很固定的套路，只要知道实现接口和方法就仿照写出。

[java] view plain copy print?

1. public class ProxySubject implements Subject{  
2.       
3.         private RealSubject realSubject;      
4.       
5.     @Override  
6.     public void request() {  
7.           
8.         realSubject.request();    
9.     }  
10. }  

动态代理还会在代理的方法中做一些其他的操作，如添加日志，时间，权限等操作。这时候就要靠InvocationHandler接口中的invoke方法。看看例子中如何实现的。

[java] view plain copy print?

1. @Override  
2. public Object invoke(Object obj, Method method, Object[] args) throws Throwable {  
3.           
4.     beforeDoing();  
5.           
6.     Object invoke = method.invoke(object, args);  
7.           
8.     afterDoing();  
9.           
10.     return invoke;  
11. }  

这些代码是我们自定义的，需要实现什么操作就写在里面。

这段代码存在于Invocationhandler对象中，这个对象会在调用Proxy的newProxyInstance的方法中传递进去。

这时候可以通过反射知道被调用方法的名字等信息，之后还是通过字符串的形式拼接处类似下面的动态代理类

[java] view plain copy print?

1. public class ProxySubject implements Subject{  
2.       
3.         private RealSubject realSubject;      
4.     @Override  
5.     public void request() {  
6.         Methond md = Subject.getMethod("methodName");  
7.         handler.invoke(this, md);    
8.     }  
9. }  

这个大概就是根据传递的接口对象和InvocationHandler结合后应该生成的代理类。但现在的问题是如何去动态的生成上面这样的代理类。

答案是使用字符串拼接的方式。

从看上面的代码可以看出，除了接口和调用方法不同其他都相同。而且我们已经通过反射获得了方法和接口名字，这样就可以按着这个“套路”去用字符串拼接成这样的一类。

大概就是下面这种代码：

[java] view plain copy print?

1. String source = "package com.gxy.proxy;" + rt   
2.   
3.         + "public class "+ClassName+"implements "+InterfaceName+ rt    
4.         + "{" + rt    
5.         +       "private "+ ClassName + ClassName.toLowerCase()+" ; " + rt  
6.                
7.         +       "@Override"  
8.         +       "public Void "+InterfaceName+ "()" + rt  + " {"  
9.         +           "Method md = "+InterfaceName+".getMethod("+ methodName+");" +rt   
10.         +           "hander.invoke(this, md);" + rt  
11.         +       "}" + rt   
12.         + "}";  

用反射生成的出来类名，接口名，方法名去动态的创建这样一个类的字符串。

之后就特定的方法去将这个字符串生成成类。在用反射把这个类取出来。这样就有了这个“动态”生成的代理类了。

就简单介绍到这吧。。。

最后大家可以发现例子中的动态代理里都是通过接口来实现的，如果对于不能实现接口的类就不能用JDK的动态代理了。如果想用就需要使用cglib了，因为cglib是针对类来实现的。

关于动态代理我研究了一个多礼拜，觉得理解起来还是比较困难的，勉勉强强的知道了个大概。

以后有时间我会继续深入的学习动态代理，但暂时还是以反射为主。下一篇准备写一下反射与注解的内容，希望大家多多支持。