java代理机制

柔光的暖阳◎ 2024-02-17 17:16 7阅读 0赞

### 1 引言 ###

我们书写执行一个功能的函数时，经常需要在其中写入与功能不是直接相关但很有必要的代 码，如日志记录，信息发送，安全和事务支持等，这些枝节性代码虽然是必要的，但它会带 来以下麻烦：

1.  枝节性代码游离在功能性代码之外，它不是函数的目的，这是对OO是一种破坏
2.  枝节性代码会造成功能性代码对其它类的依赖，加深类之间的耦合，而这是OO系统所竭 力避免的
3.  枝节性代码带来的耦合度会造成功能性代码移植困难，可重用性降低
4.  从法理上说，枝节性代码应该\`监视'着功能性代码，然后采取行动，而不是功能性代码 \`通知'枝节性代码采取行动，这好比吟游诗人应该是主动记录骑士的功绩而不是骑士主 动要求诗人记录自己的功绩

### 2 常见的代理 ###

毫无疑问，枝节性代码和功能性代码需要分开来才能降低耦合程度，符合现代OO系统的要 求，我们可以使用代理模式完成这个要求。

代理模式的作用是：为其它对象提供一种代理以控制对这个对象的访问。在某些情况下，一 个客户不想直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介作用。 代理模式一般涉及到三个角色：

1.  抽象角色：声明真实对象和代理对象的共同接口
2.  代理角色：代理对象内部包含有真实角色的引用，从而可以操作真实角色，同时代理对象 与真实对象有相同的接口，能在任何时候代替真实对象，同时代理对象可以在执行真实对 象前后加入特定的逻辑以实现功能的扩展。
3.  真实角色：代理角色所代表的真实对象，是我们最终要引用的对象

常见的代理有:

1.  远程代理(Remote Proxy)：对一个位于不同的地址空间对象提供一个局域代表对象，如RMI中的stub
2.  虚拟代理(Virtual Proxy)：根据需要将一个资源消耗很大或者比较复杂的对象，延迟加 载，在真正需要的时候才创建
3.  保护代理(Protect or Access Proxy)：控制对一个对象的访问权限。
4.  智能引用(Smart Reference Proxy)：提供比目标对象额外的服务和功能。

通过代理类这一中间层，能够有效控制对实际委托类对象的直接访问，也可以很好地隐藏和 保护实际对象，实施不同的控制策略，从而在设计上获得了更大的灵活性。

### 3 代理模式UML图 ###

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。 代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后 续处理。

![latex-table][]

### 4 代理模式实例 ###

以下以《Java与模式》中的示例为例：

// 抽象角色：
    abstract public class Subject {
        abstract public void  request();
    }
    
    // 真实角色：实现了Subject的request()方法
    public class  RealSubject  extends  Subject  {
      public  RealSubject()  { }
    
      public void  request()  {
         System.out.println( " From real subject. " );
        }
    }
    
    // 代理角色：
    public class  ProxySubject  extends  Subject  {
      // 以真实角色作为代理角色的属性
      private  Subject realSubject;
    
      public  ProxySubject(Subject realSubject)  {
         this.realSubject = realSubject }
    
      // 该方法封装了真实对象的request方法
      public void  request()  {
         preRequest();
         realSubject.request();  // 此处执行真实对象的request方法
         postRequest();
      }
      ...
    }
    
    // 客户端调用：
    RealSubject real = new RealSubject();
    Subject sub = new  ProxySubject(real);
    Sub.request();

由以上代码可以看出，客户实际需要调用的是RealSubject类的request()方法，现在用 ProxySubject来代理 RealSubject类，同样达到目的，同时还封装了其他方法 (preRequest(),postRequest())，可以处理一些其他问题。

另外，如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其 作为代理对象的内部属性。但是实际使用时，如果某一个代理要应用于－批真实角色，毎个 真实对象必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不 知道真实角色，该如何使用编写代理类呢？这个问题可以通过java的动态代理类来解决。

### 5 java动态代理 ###

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一 组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实 例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy， 它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工 作。

#### 5.1 java动态代理UML图 ####

![latex-table][latex-table 1]

java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类：

1.  Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object\[\] args)。在实际使用时，第一个参数obj一般是指代理 类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。 这个抽 象方法在代理类中动态实现。
2.  Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject。
3.  Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。
4.  Static Class getProxyClass (ClassLoader loader, Class\[\] interfaces)：获得一个 代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
5.  Static Object newProxyInstance(ClassLoader loader, Class\[\] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用 (可使用被代理类的在Subject接口中声明过的方法)。

在使用动态代理类时，我们必须实现InvocationHandler接口，以第一节中的示例为例：

// 抽象角色(之前是抽象类，此处应改为接口)：
    public  interface Subject {
      abstract  public  void request();
    }
    
    // 具体角色RealSubject：
    public  class RealSubject implements Subject {
      public RealSubject() {}
    
      public  void request() {
        System.out.println( " From real subject. " );
     }
    
    }
    
    // 代理处理器：
    import java.lang.reflect.Method;
    import java.lang.reflect.InvocationHandler;
    
    public  class DynamicSubject implements InvocationHandler {
      private Object sub;
      public DynamicSubject() {}
    
      public DynamicSubject(Object obj) {
        sub = obj;
      }
    
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println( " before calling "  + method);
        method.invoke(sub,args);
    
        System.out.println( " after calling "  + method);
        return  null ;
      }
    }

该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；此外，在该类还实现了invoke方法，该方法中的

method.invoke(sub,args);

其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，args为执 行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些 相关操作。

// 客户端：
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Method;
    
    public class Client {
    
      static public void main(String[] args) throws Throwable {
       RealSubject rs = new RealSubject(); // 在这里指定被代理类
       InvocationHandler ds = new DynamicSubject(rs);
       Class cls = rs.getClass();
    
       // 以下是一次性生成代理
       Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );
       subject.request();
      }
    }
    
    // 程序运行结果：
    before calling public abstract void Subject.request()
    From real subject.
    after calling public abstract void Subject.request()

通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口 (Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实 现了非常灵活的动态代理关系。

### 6 代理模式与装饰者模式的区别 ###

代理模式和装饰者模式很像，在典型的例子上，如spring的AOP、远程代理类、JDK的proxy， 都是代理模式。JDK里的输入/输出器是很典型的装饰器模式！但在有些场景上，对设计模式 入门的新手，还是有点难区分，UML类图基本没区别，都是实现同一个接口，一个类包装另一 个类。 两者的定义：

*  装饰器模式：能动态的新增或组合对象的行为
 *  代理模式：为其他对象提供一种代理以控制对这个对象的访问

装饰模式是“新增行为”，而代理模式是“控制访问”。关键就是我们如何判断是“新增行 为”还是“控制访问”。你在一个地方写装饰，大家就知道这是在增加功能，你写代理，大 家就知道是在限制。

#### 6.1 装饰者模式UML图 ####

![latex-table][latex-table 2]

其中类的职责如下：

1.  抽象构件角色（Project）：给出一个接口，以规范准备接收附加责任的对象
2.  具体构件角色（Employe）：定义一个将要接收附加责任的类
3.  装饰角色（Manager）：持有一个构件对象的实例，并定义一个与抽象构件接口一致的接口
4.  具体装饰角色（ManagerA、ManagerB）：负责给构件对象“贴上”附加的责任

#### 6.2 形象说明 ####

代理模式：在不改变接口的前提下，控制对象的访问

例子：孙悟空扮演并代替高家三小姐

孙悟空扮演高家三小姐，所以可以说孙悟空与高家三小姐具有共同的接口。如果猪八戒只想 见见高家三小姐的娇好面容，或者谈谈天说说地，那么高家三小姐的“代理”孙悟空是允许 的，但猪八戒想亲亲嘴，那么是不行的。这是保护代理模式的应用。只有代理对象认为合适 时，才会将客户端的请求传递给真实主题对象。

装饰模式：在不改变接口的前提下，动态扩展对象的功能

孙悟空有七十二般变化，在二郎神眼里，他永远是那只猢狲。装饰模式以对客户透明的方式 动态地给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在装饰前和装饰后有 什么不同。装饰模式可以在不使用创造更多子类的情况下，将对象的功能加以扩展。他的每 一种变化都给他带来一种附加的本领。他变成鱼儿时，就可以到水里游泳；他变成雀儿时， 就可以在天上飞行。而不管悟空怎么变化，在二郎神眼里，他永远是那只猢狲。装饰模式以 对客户透明的方式动态地给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在 装饰前和装饰后有什么不同。装饰模式可以在不使用创造更多子类的情况下，将对象的功能 加以扩展。

[latex-table]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/c39ced32778249b4a99f5b8794aa5a35.png
[latex-table 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/bd75f9c1b9294b32bbd67254510266d9.png
[latex-table 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/4c34377b677a4070b5dd2388ec4098e1.png