您的位置: 首页  >  IT文章  >  Java二十三设计模式之-----代理模式 一、代理模式（Proxy） 二、静态代理和动态代理

Java二十三设计模式之-----代理模式 一、代理模式（Proxy） 二、静态代理和动态代理

分类: IT文章 • 2023-11-10 09:08:07

其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。先来看看关系图：

Java二十三设计模式之-----代理模式 一、代理模式（Proxy） 二、静态代理和动态代理

根据上文的阐述，代理模式就比较容易的理解了，我们看下代码：

 
  1. public interface Sourceable {  
  2.     public void method();  
  3. }  
 
  1. public class Source implements Sourceable {  
  2.   
  3.     @Override  
  4.     public void method() {  
  5.         System.out.println("the original method!");  
  6.     }  
  7. }  
 
  1. public class Proxy implements Sourceable {  
  2.   
  3.     private Source source;  
  4.     public Proxy(){  
  5.         super();  
  6.         this.source = new Source();  
  7.     }  
  8.     @Override  
  9.     public void method() {  
  10.         before();  
  11.         source.method();  
  12.         atfer();  
  13.     }  
  14.     private void atfer() {  
  15.         System.out.println("after proxy!");  
  16.     }  
  17.     private void before() {  
  18.         System.out.println("before proxy!");  
  19.     }  
  20. }  

测试类：

 
  1. public class ProxyTest {  
  2.   
  3.     public static void main(String[] args) {  
  4.         Sourceable source = new Proxy();  
  5.         source.method();  
  6.     }  
  7.   
  8. }  

输出：

before proxy!
the original method!
after proxy!

代理模式的应用场景：

如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

相信一些细心的朋友已经发现了，代理模式和装饰模式很像，都实现基础对象（被装饰对象，被代理对象）实现的接口，在自身对象中保存这基础对象的引用。我们来看看两者的定义

装饰者模式的定义：动态的将责任附加到被装饰者对象上，用于扩展对象的功能。比继承的灵活性大。典型的如Java IO的设计即是装饰者模式的典型应用。
代理模式模式的定义：对其他对象进行代理，以控制对被代理对象的访问。Spring的为业务逻辑层方法生成的代理类，主要进行一些事务控制等。
由定义可以看出装饰的责任是扩展功能 ，而代理主要控制访问。

用代理模式，代理类可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，常常在一个代理类中创建一个对象的实例。
但是当我们使用装饰器模式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。
原文 https://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.html

二、静态代理和动态代理

按照代理的创建时期，代理类可以分为两种： 

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

动态：在程序运行时运用反射机制动态创建而成。

 

上面一段例子就是典型的静态代理

静态代理的缺点：

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

2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。

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

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

 

引入动态代理：

根据如上的介绍，你会发现每个代理类只能为一个接口服务，这样程序开发中必然会产生许多的代理类，所以我们就会想办法可以通过一个代理类完成全部的代理功能，那么我们就需要用动态代理

 

在上面的示例中，一个代理只能代理一种类型，而且是在编译器就已经确定被代理的对象。而动态代理是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象

 

在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持

java.lang.reflect.InvocationHandler接口的定义如下：

  1. //Object proxy:被代理的对象  
  2. //Method method:要调用的方法  
  3. //Object[] args:方法调用时所需要参数  
  4. public interface InvocationHandler {  
  5.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;  
  6. }  


java.lang.reflect.Proxy类的定义如下：

 

  1. //CLassLoader loader:类的加载器  
  2. //Class<?> interfaces:得到全部的接口  
  3. //InvocationHandler h:得到InvocationHandler接口的子类的实例  
  4. public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException  


动态代理：

具体实现类

  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. }  


动态创建代理对象的类

  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函数我们就获得了一个动态代理对象。

 

客户端代码

 
  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(面向切面编程)的基本原理。

原文  http://blog.csdn.net/hejingyuan6/article/details/36203505

相关推荐