动态代理（Dynamic Proxy）

动态代理

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

(1). Interface InvocationHandler ：该接口中仅定义了一个方法 Object ： invoke(Object obj,Method method, Object[] args) 。在实际使用时，第一个参数 obj 一般是指代理类， method 是被代理的方法，如上例中的 request() ， args 为该方法的参数数组。这个抽象方法在代理类中动态实现。

(2).Proxy ：该类即为动态代理类，作用类似于上例中的 ProxySubject ，其中主要包含以下内容：

Protected Proxy(InvocationHandler h) ：构造函数，估计用于给内部的 h 赋值。

Static Class getProxyClass (ClassLoader loader, Class[] interfaces) ：获得一个代理类，其中 loader 是类装载器， interfaces 是真实类所拥有的全部接口的数组。

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) ：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。

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

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

抽象角色 (之前是抽象类，此处应改为接口)：

public interface Subject

{

    abstract public void request();

}

具体角色 RealSubject ：同上；

 

代理角色：

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();

      // 以下是分解步骤

      /*

      Class c = Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces()) ;

      Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class});

      Subject subject =(Subject) ct.newInstance(new Object[]{ds});

     */

     // 以下是一次性生成

      Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(),

                                 cls.getInterfaces(),ds );

      subject.request();

}

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

我的理解：

    代理人（DynamicSubject）和被代理人（RealSubject）都是先定义好的，代理也定义好了他要做的附加工作在invoke中，但他不知道自己要代理谁，这要到运行时才能确定，Proxy提供静态方法在运行时动态创建代理类的字节码，然后通过反射产生代理类的实例。加载时要求提供被代理类的加载器，确保代理类和被代理类在同一个类加载器中加载。

java.lang.reflect.Proxy是所有动态代理的父类，在上例中Proxy就是Proxy.newProxyInstance产生的类的父类。Proxy持有一个实现InvocationHandler接口的类的引用。