设计模式之代理模式的三种实现方式

概念

为其他对象提供一种代理以控制对这个对象的访问。

在Java中代理模式的实现大概可分为三种：静态代理、动态代理、CGlib代理。

1. 静态代理

静态代理，代理类和被代理类(也即目标对象)需实现同一个接口，保证外部调用知道是哪个接口。代理类中维护目标对象，在方法里执行目标对象的方法。
缺点是，需要为每一个目标对象都构建一个代理类，目标对象数量多的话则代理类也多。

关键点：

• 代理类需实现和目标对象同一个接口；

接口，代理类和被代理类需要共同实现的接口

public interface DemoService {
    void run();
}

被代理类，也即目标类

public class DemoServiceImpl implements DemoService{

    @Override
    public void run() {
        System.out.println("执行目标对象的方法。");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

代理类，代理DemoServiceImpl的实现，执行业务逻辑

/**
 * 代理类，维护目标对象，执行业务逻辑 及 调用目标对象方法
 */
public class DemoServiceProxy implements DemoService {

    // 维护目标对象
    private DemoService service;

    DemoServiceProxy(DemoService service) {
        this.service = service;
    }

    @Override
    public void run() {
        System.out.println("代理类对象方法执行；" );
        long startTime = System.currentTimeMillis();

        // 执行目标方法
        service.run();

        // 记录耗时
        long endTime = System.currentTimeMillis();
        System.out.println("方法执行结束。耗时：" + (endTime - startTime) + "ms");
    }

}

调用的客户端

/**
 * 调用Demo的客户端类
 */
public class DemoClient {

    public static void main(String[] args) {

        // 目标对象
        DemoService service = new DemoServiceImpl();
        // 代理对象,把目标对象传给代理对象,建立代理关系
        DemoService serviceProxy = new DemoServiceProxy(service);
        // 执行方法
        serviceProxy.run();
    }
}

好处：目标对象只需要关注核心逻辑，业务逻辑交由代理类来实现，例如入参打印，耗时情况，以及异常处理等。

缺点：代理类需要实现接口的所有方法。

2. 动态代理

2.1 JDK 自带的实现

动态代理，代理类由Jdk的Proxy提供的newInstance方法可以生成某个对象的代理对象。该方法需要三个参数，分别是代理对象的类加载器、被代理类的接口、代理对象处理器。其中代理对象处理器为实现InvocationHandler接口，重写invoke方法。
被代理类需实现接口。
缺点是，目标对象需有接口。

关键点：

• 代理拦截实现 InvocationHandler接口，重写invoke方法；
• invoke方法有三个参数
  • proxy 代理对象实例
  • method 运行时调用的方法，也即目标对象需要执行的方法，Object obj = method.invoke(target);
  • args method 方法执行所需要的参数
• 代理拦截中需维护目标对象target
• 使用Proxy#newProxyInstance 获取代理对象，三个参数：
  • 目标对象的类加载器：target.getClass().getClassLoader()；
  • 目标对象的接口：target.getClass().getInterfaces()；
  • 实现InvocationHandler 的子类对象；

代理工厂以及代理实现

/**
 * 获取代理对象的工厂类
 */
public class DemoProxyFactory {

    // 目标对象。即被代理类
    private Object target;

    public DemoProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxyInstance() {
        InvocationHandler handler = new DemoServiceHandler();
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),handler);
    }

    class DemoServiceHandler implements InvocationHandler {
        /**
         * 代理执行方法
         * @param proxy  代理对象实例
         * @param method 运行时调用的方法，也即目标对象需要执行的方法
         * @param args  method 方法执行所需要的参数
         * @return
         * @throws Throwable
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("代理对象方法执行。proxy.class="+proxy.getClass().getCanonicalName());
            long startTime = System.currentTimeMillis();
            // 执行目标对象
            Object obj = method.invoke(target);
            // 记录耗时
            long endTime = System.currentTimeMillis();
            System.out.println("方法执行结束。耗时：" + (endTime - startTime) + "ms");
            return obj;
        }
    }

}

客户端调用

public class DemoClient {

    public static void main(String[] args) {

        DemoService service = new DemoServiceImpl();    // 目标对象
        DemoProxyFactory factory = new DemoProxyFactory(service);   // 构建代理工厂

        DemoService serviceProxy  = (DemoService)factory.getProxyInstance(); // 通过代理工厂获取代理类
        serviceProxy.run();
    }
}   

2.2 CGlib 代理的实现

CGlib代理是为了解决动态代理而生的，也被称为子类代理。通过实现MethodInterceptor接口，在内存中动态构建目标对象的子类，也即代理对象做扩展。其中动态构建目标对象子类通过Enhancer工具类构建，主要是设置父类，设置回调函数，创建子类。

关键点：

• 引入cglib的包；
• 实现cglib包里的接口MethodInterceptor，重写intercept方法；
• intercept方法有四个参数：
  • Object o：cglib生成的代理类实例
  • Method method：目标方法，Object obj = method.invoke(target) 或 methodProxy.invokeSuper(target)
  • Object[] objects：目标方法的参数列表
  • MethodProxy methodProxy：生成的代理类对方法的代理引用
• 需维护目标对象 target
• 使用Enhancer工具类创建子类代理实例
  • 设置父类；
  • 设置回调对象，即实现MethodInterceptor接口的子类实例；
  • 创建子类代理对象

需要额外引入cglib的依赖

  <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>3.2.10</version>
  </dependency>

目标类

public class DemoCglibService {

    public void run() {
        System.out.println("执行目标对象的方法。");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

方法拦截器的实现，

public class DemoCglibInterceptor implements MethodInterceptor {

    private Object target;

    public DemoCglibInterceptor(Object target) {
        this.target = target;
    }

    public Object getProxyInstance() {
        // 工具类
        Enhancer enhancer = new Enhancer();
        // 设置父类
        enhancer.setSuperclass(target.getClass());
        // 设置回调函数。回调到当前对象（因为当前对象就是callBack的实现
        enhancer.setCallback(this);

        return enhancer.create();   // 创建子类代理对象
    }



    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("代理对象方法执行。");
        long startTime = System.currentTimeMillis();
        // 执行目标对象
        Object obj = method.invoke(target);
        // 记录耗时
        long endTime = System.currentTimeMillis();
        System.out.println("方法执行结束。耗时：" + (endTime - startTime) + "ms");
        return obj;
    }
}

获取子类代理的工厂类

/**
 * 代理工厂
 */
public class DemoProxyFactory {

    /**
     * 获取子类代理对象实例
     * @param target  目标对象
     * @param callback 实现了 MethodInterceptor 的子类
     * @return
     */
    public static Object getProxyInstance(Object target, Callback callback) {
        // 工具类
        Enhancer enhancer = new Enhancer();
        // 设置父类
        enhancer.setSuperclass(target.getClass());
        // 设置回调函数。
        enhancer.setCallback(callback);

        return enhancer.create();   // 创建子类代理对象
    }
}

客户端调用

public class DemoClient {

    public static void main(String[] args) {

        System.out.println("方法一：使用方法拦截对象的方法获取代理对象");
        DemoCglibService service = new DemoCglibService();
        DemoCglibInterceptor cglibInterceptor = new DemoCglibInterceptor(service);

        DemoCglibService serviceProxy = (DemoCglibService) cglibInterceptor.getProxyInstance();
        serviceProxy.run();

        System.out.println("\n");

        System.out.println("方法二：使用代理工厂获取子类代理对象");
        DemoCglibService serviceProxy2 = (DemoCglibService) DemoProxyFactory.getProxyInstance(service,cglibInterceptor);
        serviceProxy2.run();
    }
}

注：如果使用Spring框架的话，就不需要额外引入cglib包了，因为Spring核心包已经包括了cglib功能，所以直接引入spring-core.jar即可。（Maven的传递依赖）