动态代理模式

一、动态代理类

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)、 通过代理调用方法。

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

你可能感兴趣的:(动态代理模式)