动态代理模式

一、动态代理类

1、Java的动态代理类位于java.lang.reflect包下。一般主要涉及到下面两个类：

(1) Interface InvocationHandler。该接口只定义了一个方法

 /**
   * @param proxy 该方法被调用的代理实例
   * @param method 被代理对象想要执行的方法
   * @param args 所执行方法的参数
  */
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

(2) Proxy。该类为动态代理类，作用相当于静态代理中的ProxySubject。主要有下面三个方法：

//构造函数，用于给内部的h赋值。
protected Proxy(InvocationHandler h)

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

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

2、Dynamic Proxy是在运行时生成的class，生成它时必须提供一组接口，然后它就宣称实现了这些接口，因此可以把它当做这些接口中的任意一个来用。实际上，这个Dynamic Proxy就是一个Proxy，它并不会完成实质的工作，在生成它的实例时必须提供一个InvocationHandler实例，由它来完成实际的工作。

二、demo说明

• 各个文件介绍

//Subject.java  //抽象角色
//RealSubject.java //真实角色
//DynamicSubject.java //代理角色
//Client.java   //客户端

1、 Subject.java

public interface Subject
{
    public void request();
}

2、RealSubject.java

public class RealSubject implements Subject
{
    @Override
    public void request()
    {
        System.out.println("From real Subject!");
    }
}

3、DynamicSubject.java

/**
 * 动态代理类
 * 动态代理类必须实现InvocationHandler接口
 *该代理类内部属性是Object对象，实际使用时通过构造方法传进一个来一个对象
 *此外，该代理类还实现了invoke方法，该方法中的method.invoke就是执行
 *被代理对象想要执行的方法，方法参数是sub，表示该方法从属于sub。同时我们
 *还可以在执行真实对象的方法前后添加一些额外的方法。
 * @author Chuan
 *
 */
public class DynamicSubject implements InvocationHandler
{
    private Object sub;
    
    public DynamicSubject(Object object)
    {
        this.sub = object;
    }

    /**
     * @param proxy 该方法被调用的代理实例
     * @param method 被代理对象想要执行的方法
     * @param args 所执行方法的参数
     */
    @Override
    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;
    }

}

4、Client.java

public class Client
{
    public static void main(String[] args)
    {
        RealSubject realSubject = new RealSubject();
        
        InvocationHandler handler = new DynamicSubject(realSubject);
        
        /**
                 *Proxy.newProxyInstance()一次性生成代理类
         * Proxy.newProxyInstance()方法的第一个参数是代理类的装载器
         * 第二个参数是代理类应该实现的接口，即被代理类实现的接口
         * 第三个参数 是一个InvocationHandler
         * 
         * 最后在执行过程中动态生成一个$Proxy0对象，
         * $Proxy0类实现了Subject接口（realSubject.getClass().getInterfaces()）
         */
        Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), 
                realSubject.getClass().getInterfaces(), handler);
        //代理对象调用方法，实际上是转到动态代理中的invoke方法，并执行
        subject.request();
        
        System.out.println(subject.getClass());
    }
}

3、动态代理的步骤
(1)、创建一个实现了InvocationHandler接口的类，它必须实现invoke方法；
(2)、创建被代理的类以及接口；
(3)、通过Proxy的静态方法newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)创建一个代理；
(4)、 通过代理调用方法。

上一篇：静态代理模式
下一篇：注解