proxy静态代理

以前学习设计模式时，基本一直接触的是静态的设计模式，静态代理模式虽然简单易用，但是存在诸多问题。

代理模式

    说一下我对代理模式的理解：因为需要对一些函数进行二次处理，或是某些函数不让外界知道时，可以使用代理模式，通过访问第三方，简介访问原函数的方式，达到以上目的，来看一下代理模式的类图：

    

   总的来说，就是通过ProxySubject代理类，对原RealSubject的访问提供控制。

静态代理

    接口UserManager

[java]  view plain  copy

 print ?

1. /*** 
2.  * 用户控制接口 
3.  * @author Administrator 
4.  * 
5.  */  
6. public interface UserManager {  
7.   
8.     public void addUser(String userId,String userName);  
9.     public void modifyUser(String userId,String userName);  
10.     public void delUser(String userId);  
11.     public String findUser(String userId);  
12. }  

    实现类UserManagerImpl

[java]  view plain  copy

 print ?

1. /**** 
2.  * 用户管理真正的实现类 
3.  * @author Administrator 
4.  * 
5.  */  
6. public class UserManagerImpl implements UserManager {  
7.   
8.     /***** 
9.      * 添加用户 
10.      */  
11.     public void addUser(String userId, String userName) {  
12.             System.out.println("正在添加用户,用户为："+userId+userName+"……");  
13.     }  
14.     /***** 
15.      * 删除用户 
16.      */  
17.     public void delUser(String userId) {  
18.         System.out.println("delUser,userId="+userId);  
19.     }  
20.     /*** 
21.      * 查找用户 
22.      */  
23.     public String findUser(String userId) {  
24.         System.out.println("findUser,userId="+userId);  
25.         return userId;  
26.     }  
27.   
28.     public void modifyUser(String userId, String userName) {  
29.         System.out.println("modifyUser,userId="+userId);  
30.     }  
31. }  

    代理类Proxy

[java]  view plain  copy

 print ?

1. /*** 
2.  * 代理类，提供用户实现类的访问控制 
3.  * @author Administrator 
4.  * 
5.  */  
6. public class Proxy implements UserManager{  
7.     private UserManager userManager;  
8.     public Proxy(UserManagerImpl ul)  
9.     {  
10.         userManager=ul;  
11.     }  
12.     public void addUser(String userId, String userName) {  
13.         System.out.println("正在进行添加用户前的准备工作,用户id为："+userId+"……");  
14.         try {  
15.             userManager.addUser(userId, userName);  
16.             System.out.println("成功添加用户"+userId+"，正在进行确认处理……");  
17.         } catch (Exception e) {  
18.             System.out.println("添加,userId="+userId+"失败！");  
19.         }  
20.           
21.           
22.     }  
23.   
24.     public void delUser(String userId) {  
25.         // TODO Auto-generated method stub  
26.           
27.     }  
28.   
29.     public String findUser(String userId) {  
30.         // TODO Auto-generated method stub  
31.         return null;  
32.     }  
33.   
34.     public void modifyUser(String userId, String userName) {  
35.         // TODO Auto-generated method stub  
36.     }  
37. }  

    客户端Client

[java]  view plain  copy

 print ?

1. /**** 
2.  * 客户端 
3.  * @author Administrator 
4.  * 
5.  */  
6. public class client {  
7.   
8.         public static void main(String []args)  
9.         {  
10.             UserManager userManager=new Proxy( new UserManagerImpl());  
11.             userManager.addUser("0001", "张三");  
12.         }  
13. }  

    运行结果

    

    时序图

    

静态代理的弊端

    如果我们为每个方法都使用“正在进行添加用户前的准备工作”、“成功添加用户，正在进行确认处理”等处理，很显然每个代理方法中都要重复这些代码；并且如果要想为多个类进行代理，则需要建立多个代理类，维护难度加大。

    仔细想想，为什么静态代理会有这些问题，是因为代理在编译期就已经决定，如果代理哪个发生在运行期，这些问题解决起来就比较简单，所以动态代理的存在就很有必要 

优点：

 

代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合），对于如上的客户端代码，newUserManagerImpl()可以应用工厂将它隐藏，如上只是举个例子而已。

 

缺点：

1）代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserManager类的访问提供了代理，但是如果还要为其他类如Department类提供代理的话，就需要我们再次添加代理Department的代理类。

 

举例说明：代理可以对实现类进行统一的管理，如在调用具体实现类之前，需要打印日志等信息，这样我们只需要添加一个代理类，在代理类中添加打印日志的功能，然后调用实现类，这样就避免了修改具体实现类。满足我们所说的开闭原则。但是如果想让每个实现类都添加打印日志的功能的话，就需要添加多个代理类，以及代理类中各个方法都需要添加打印日志功能（如上的代理方法中删除，修改，以及查询都需要添加上打印日志的功能）

即静态代理类只能为特定的接口(Service)服务。如想要为多个接口服务则需要建立很多个代理类。

1.产生代理类$Proxy0类

执行了Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

将产生$Proxy0类，它继承Proxy对象，并根据第二个参数，实现了被代理类的所有接口，自然就可以生成接口要实现的所有方法了（这时候会重写hashcode，toString和equals三个方法），但是还没有具体的实现体；

2.    将代理类$Proxy0类加载到JVM中

这时候是根据Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)它的第一个参数----就是被代理类的类加载器，把当前的代理类加载到JVM中

3.    创建代理类$Proxy0类的对象

调用的$Proxy0类的$Proxy0（InvocationHandler）构造函数，生成$Proxy0类的对象

参数就是Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)它的第三个参数

这个参数就是我们自己实现的InvocationHandler对象，我们知道InvocationHandler对象中组合加入了代理类代理的接口类的实现类；所以，$Proxy0对象调用所有要实现的接口的方法，都会调用InvocationHandler对象的invoke（）方法实现；

4.    生成代理类的class byte

动态代理生成的都是二进制class字节码

动态代理：

 

具体实现类

[java]  view plain  copy

 print ?

1. public class UserManagerImpl implements UserManager {  
2.   
3.     @Override  
4.     public void addUser(String userId, String userName) {  
5.         System.out.println("UserManagerImpl.addUser");  
6.     }  
7.   
8.     @Override  
9.     public void delUser(String userId) {  
10.         System.out.println("UserManagerImpl.delUser");  
11.     }  
12.   
13.     @Override  
14.     public String findUser(String userId) {  
15.         System.out.println("UserManagerImpl.findUser");  
16.         return "张三";  
17.     }  
18.   
19.     @Override  
20.     public void modifyUser(String userId, String userName) {  
21.         System.out.println("UserManagerImpl.modifyUser");  
22.   
23.     }  
24.   
25. }  

动态创建代理对象的类

[java]  view plain  copy

 print ?

1. //动态代理类只能代理接口（不支持抽象类），代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类  
2.      
3. public class LogHandler implements InvocationHandler {  
4.   
5.     // 目标对象  
6.     private Object targetObject;  
7.     //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。              
8.     public Object newProxyInstance(Object targetObject){  
9.         this.targetObject=targetObject;  
10.         //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例    
11.         //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器  
12.         //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口  
13.         //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法  
14.         //根据传入的目标返回一个代理对象  
15.         return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),  
16.                 targetObject.getClass().getInterfaces(),this);  
17.     }  
18.     @Override  
19.     //关联的这个实现类的方法被调用时将被执行  
20.     /*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/  
21.     public Object invoke(Object proxy, Method method, Object[] args)  
22.             throws Throwable {  
23.         System.out.println("start-->>");  
24.         for(int i=0;i<args.length;i++){  
25.             System.out.println(args[i]);  
26.         }  
27.         Object ret=null;  
28.         try{  
29.             /*原对象方法调用前处理日志信息*/  
30.             System.out.println("satrt-->>");  
31.               
32.             //调用目标方法  
33.             ret=method.invoke(targetObject, args);  
34.             /*原对象方法调用后处理日志信息*/  
35.             System.out.println("success-->>");  
36.         }catch(Exception e){  
37.             e.printStackTrace();  
38.             System.out.println("error-->>");  
39.             throw e;  
40.         }  
41.         return ret;  
42.     }  
43.   
44. }  

被代理对象targetObject通过参数传递进来，我们通过targetObject.getClass().getClassLoader()获取ClassLoader对象，然后通过targetObject.getClass().getInterfaces()获取它实现的所有接口，然后将targetObject包装到实现了InvocationHandler接口的LogHandler对象中。通过newProxyInstance函数我们就获得了一个动态代理对象。

 

客户端代码

[java]  view plain  copy

 print ?

1. public class Client {  
2.   
3.     public static void main(String[] args){  
4.         LogHandler logHandler=new LogHandler();  
5.         UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());  
6.         //UserManager userManager=new UserManagerImpl();  
7.         userManager.addUser("1111", "张三");  
8.     }  
9. }  

可以看到，我们可以通过LogHandler代理不同类型的对象，如果我们把对外的接口都通过动态代理来实现，那么所有的函数调用最终都会经过invoke函数的转发，因此我们就可以在这里做一些自己想做的操作，比如日志系统、事务、拦截器、权限控制等。这也就是AOP(面向切面编程)的基本原理。

动态代理优点：

 

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强