设计模式——结构型之借助动态代理模式（Proxy Pattern）体验"间接的美"(二)

引言

前面一篇文章总结了代理模式中静态模式的使用，这一篇主要总结下动态代理模式的相关知识，照例把结构型设计模式的相关文章地址列表贴一下：

• 设计模式——结构型之借助代理模式（Proxy
  Pattern）体验”间接的美”(一)

一、动态代理概述

前一篇文章所说根据代理类生成的时间和机制可以将代理可以分为两大类：动态代理与静态代理，静态代理则是由我们自己创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了；而在编码阶段我们不知道被代理对象是谁，动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定，代理对象是在运行阶段动态生成的（一般是通过反射机制），动态代理的实现十分简单，因为JDK 自身已经为我提供了一个便捷的动态代理接口InvocationHandler，我们只需要实现该接口并重写invoke方法即可，前面步骤和静态代理差不多（略），区别在代理类的实现。

二、与动态代理实现相关的几个重要java api

1、java.lang.reflect.Proxy

java.lang.reflect.Proxy是 Java 动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。

Proxy类的静态方法	说明
static InvocationHandler getInvocationHandler(Object proxy)	用于获取指定代理对象所关联的调用处理器
static Class getProxyClass(ClassLoader loader, Class[] interfaces)	用于获取关联于指定类装载器和一组接口的动态代理类的类对象
static boolean isProxyClass(Class cl)	用于判断指定类对象是否是一个动态代理类
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)	用于为指定类装载器、一组接口及调用处理器生成动态代理类实例

2、java.lang.reflect.InvocationHandler

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

    /** * 该方法负责集中处理动态代理类上的所有方法调用，调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行 * @param proxy 代理类实例 * @param method 被调用的方法对象 * @param args 被调用的方法的调用参数 */
    Object invoke(Object proxy, Method method, Object[] args)

3、获取动态代理对象的背后过程

我们使用Proxy类的静态方法newProxyInstance就可以直接获取到动态代理对象了，实际上背后还有一个过程，只是Proxy类的静态方法newProxyInstance进行了简化。

• InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发，其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用

InvocationHandler handler = new InvocationHandlerImpl(..);   

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

// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象  
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 

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

// 通过反射从生成的类对象获得构造函数对象 
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); 

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

// 通过构造函数对象创建动态代理类实例 
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

三、动态代理机制的特征

1、动态代代理中包package的特点

如果所代理的接口都是 public 的，那么它将被定义在顶层包（即包路径为空）；如果所代理的接口中有非 public 的接口（因为接口不能被定义为 protect 或 private，所以除 public 之外就是默认的 package 访问级别），那么它将被定义在该接口所在包（假设代理了 com.ibm.developerworks 包中的某非 public 接口 A，那么新生成的代理类所在的包就是 com.ibm.developerworks），这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问。

2、类的修饰符

该代理类具有 final 和 public 修饰符，意味着它可以被所有的类访问，但是不能被再度继承；

3、类名

格式是“$ProxyN”，其中 N 是一个逐一递增的阿拉伯数字，代表 Proxy 类第 N 次生成的动态代理类，值得注意的一点是，并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加，原因是如果对同一组接口（包括接口排列的顺序相同）试图重复创建动态代理类，它会很聪明地返回先前已经创建好的代理类的类对象，而不会再尝试去创建一个全新的代理类，这样可以节省不必要的代码重复生成，提高了代理类的创建效率。

4、类继承关系

Proxy 类是它的父类，这个规则适用于所有由 Proxy 创建的动态代理类。而且该类还实现了其所代理的一组接口，这就是为什么它能够被安全地类型转换到其所代理的某接口的根本原因。接下来让我们了解一下代理类实例的一些特点。每个实例都会关联一个调用处理器对象，可以通过 Proxy 提供的静态方法 getInvocationHandler 去获得代理类实例的调用处理器对象。在代理类实例上调用其代理的接口中所声明的方法时，这些方法最终都会由调用处理器的 invoke 方法执行，此外，值得注意的是，代理类的根类 java.lang.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法执行，它们是 hashCode，equals 和 toString，可能的原因有：一是因为这些方法为 public 且非 final 类型，能够被代理类覆盖；二是因为这些方法往往呈现出一个类的某种特征属性，具有一定的区分度，所以为了保证代理类与委托类对外的一致性，这三个方法也应该被分派到委托类执行。当代理的一组接口有重复声明的方法且该方法被调用时，代理类总是从排在最前面的接口中获取方法对象并分派给调用处理器，而无论代理类实例是否正在以该接口（或继承于该接口的某子接口）的形式被外部引用，因为在代理类内部无法区分其当前的被引用类型。接着来了解一下被代理的一组接口有哪些特点。首先，要注意不能有重复的接口，以避免动态代理类代码生成时的编译错误。其次，这些接口对于类装载器必须可见，否则类装载器将无法链接它们，将会导致类定义失败。再次，需被代理的所有非 public 的接口必须在同一个包中，否则代理类生成也会失败。最后，接口的数目不能超过 65535，这是 JVM 设定的限制。最后再来了解一下异常处理方面的特点。从调用处理器接口声明的方法中可以看到理论上它能够抛出任何类型的异常，因为所有的异常都继承于 Throwable 接口，但事实是否如此呢？答案是否定的，原因是我们必须遵守一个继承原则：即子类覆盖父类或实现父接口的方法时，抛出的异常必须在原方法支持的异常列表之内。所以虽然调用处理器理论上讲能够，但实际上往往受限制，除非父接口中的方法支持抛 Throwable 异常。那么如果在 invoke 方法中的确产生了接口方法声明中不支持的异常，那将如何呢？放心，Java 动态代理类已经为我们设计好了解决方法：它将会抛出 UndeclaredThrowableException 异常。这个异常是一个 RuntimeException 类型，所以不会引起编译错误。通过该异常的 getCause 方法，还可以获得原来那个不受支持的异常对象，以便于错误诊断。

四、动态代理的优点和不足

1、动态代理的优点

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。在本示例中看不出来，因为invoke方法体内嵌入了具体的外围业务（记录任务处理前后时间并计算时间差），实际中可以类似

2、动态代理的不足

诚然，Proxy 已经设计得非常优美，但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持 interface 代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫 Proxy。Java 的继承机制注定了这些动态代理类们无法实现对 class 的动态代理，原因是多继承在 Java 中本质上就行不通。有很多条理由，人们可以否定对 class 代理的必要性，但是同样有一些理由，相信支持 class 动态代理会更美好。接口和类的划分，本就不是很明显，只是到了 Java 中才变得如此的细化。如果只从方法的声明及是否被定义来考量，有一种两者的混合体，它的名字叫抽象类。实现对抽象类的动态代理，相信也有其内在的价值。此外，还有一些历史遗留的类，它们将因为没有实现任何接口而从此与动态代理永世无缘。如此种种，不得不说是一个小小的遗憾。

五、动态代理的实现

动态代理的实现很简单，除了构造代理对象之外，其他步骤与静态代理实现步骤一致，为了节省篇幅省略其他步骤的代码，具体参见上一篇设计模式——结构型之借助代理模式（Proxy
Pattern）体验”间接的美”(一)，以下是动态代理中构造代理对象的一般步骤：

• 实现动态代理接口InvocationHandler
• 持有被代理对象的引用，由于被代理对象未知，所以使用Object类型
• 通过构造方法传递被代理对象的引用
• 重写invoke方法，并在方法中通过反射调用被代理类的方法，如果在invoke方法中我们可以得知传来的方法对象和参数数组，所以如果要区别处理的话只需要在这里进行判断和添加额外的逻辑就可以了。

package proxy.statics;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxySubject implements InvocationHandler {
    private Object obj;//持有被代理对象的引用

    public DynamicProxySubject(Object obj){
        this.obj=obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //利用反射机制将请求分派给委托类处理。Method的invoke返回Object对象作为方法执行结果。 因为示例程序没有返回值，所以这里忽略了返回值处理 
        if("submit".equals(method.getName())){
            System.out.println("代理人接受被代理人的委托，拿到原告的事先写好的诉讼书并向法院提交...");
            method.invoke(obj, args);

        }else if("proof".equals(method.getName())){
            System.out.println("代理人接受被代理人的委托，把原告准备的材料提交到法庭上...");
            method.invoke(obj, args);

        }
        return null;
    }

}

测试

package proxy.statics;

import java.lang.reflect.Proxy;

public class Client {

    public static void main(String[] args) {
        AbstractSubject subject = new RealSubject();
        ProxySubject proxy = new ProxySubject(subject);
        proxy.submit();
        proxy.proof();
        System.out.println("**********完完全全对客户端隐藏****************");
        // 完全隐藏
        AbstractSubject proxy2 = SubjectStaticFactory.getInstance();
        proxy2.submit();
        proxy2.proof();
        System.out.println("**********动态代理****************");
        //动态代理
        AbstractSubject suiter=new RealSubject();//构造一个被代理对象

        DynamicProxySubject dynaProxyer=new DynamicProxySubject(suiter);//构造一个动态代理
        ClassLoader loader=suiter.getClass().getClassLoader();
        //动态构造一个具体的代理对象，在这绑定上了被代理对象
        AbstractSubject dynaSuiter=(AbstractSubject) Proxy.newProxyInstance(loader, new Class[]{AbstractSubject.class}, dynaProxyer);
        dynaSuiter.submit();
        dynaSuiter.proof();

    }

}

由以上例子不难得出，动态代理其实是同一个动态代理类来来代理N多个不同的代理类，为的就是对被代理者和代理者解耦，而静态代理这是只能在开发阶段就决定了被代理者。

六、代理的具体分类

1、远程代理

为位于两个不同地址空间对象的访问提供了一种实现机制，可以将一些消耗资源较多的对象和操作移至性能更好的计算机上，提高系统的整体运行效率。

2、虚拟代理

虚拟代理的基本思想其实和延迟初始化相似，如果需要创建一个资源消耗较大的复杂对象，先创建一个小的对象来表示，等到真正需要用的时候才会创建真实的对象。当用户请求一个大的对象时候，虚拟代理暂时充当真实对象的角色，待该真实对象真正被创建出来之后，虚拟代理就会将用户请求委托给真是对象。简而言之，使用一个代理对象暂时表示一个消耗巨大资源的真实对象，而真是对象仅仅在真正使用的时候才被创建。
虚拟代理模式(Virtual Proxy)是一种节省内存的技术，它建议创建那些占用大量内存或处理复杂的对象时，把创建这类对象推迟到使用它的时候。在特定的应用中，不同部分的功能由不同的对象组成，应用启动的时候，不会立即使用所有的对象。在这种情况下，虚拟代理模式建议推迟对象的创建直到应用程序需要它为止。对象被应用第一次引用时创建并且同一个实例可以被重用。这种方法优缺点并存。

2.1、虚拟代理的优点

这种方法的优点是，在应用程序启动时，由于不需要创建和装载所有的对象，因此加速了应用程序的启动。

2.1、虚拟代理的缺点

因为不能保证特定的应用程序对象被创建，在访问这个对象的任何地方，都需要检测确认它不是空(null)。也就是，这种检测的时间消耗是最大的缺点。

2.3、虚拟代理的使用逐一实现

应用虚拟代理模式，需要设计一个与真实对象具有相同接口的单独对象（指虚拟代理）。不同的客户对象可以在创建和使用真实对象地方用相应的虚拟对象来代替。虚拟对象把真实对象的引用作为它的实例变量维护。代理对象不要自动创建真实对象，当客户需要真实对象的服务时，调用虚拟代理对象上的方法，并且检测真实对象是否被创建。如果真实对象已经创建，代理把调用转发给真实对象，如果真实对象没有被创建：

• 代理对象创建真实对象

• 代理对象把这个对象分配给引用变量。

• 代理把调用转发给真实对象

按照这种安排，验证对象存在和转发方法调用这些细节对于客户是不可见的。客户对象就像和真实对象一样与代理对象进行交互。因此客户从检测真实对象是否为null中解脱出来，另外，由于创建代理对象在时间和处理复杂度上要少于创建真实对象。因此，在应用程序启动的时候，用代理对象代替真实对象初始化。

3、保护代理

当原始对象有不同的访问权限时，使用代理控制对原始对象的访问。可以控制对一个对象的访问权限，为不同用户提供不同级别的使用权限。

4、智能引用

在访问原始对象时执行一些代理自己附加的操作并对原始对象的引用计数。