代理模式（Proxy Pattern）

简述

代理模式是一种结构型设计模式，代理模式主要包含三种角色：抽象对象角色、目标对象角色、代理对象角色，代理模式主要通过抽象对象角色来为目标对象提供一个代理对象，并由代理对象控制对原对象的引用，提供了一种对目标对象另外的访问方式，这样做的好处是，可以在目标对象实现的基础上，增加丰富额外的功能，即扩展目标对象的功能。

分类

代理模式主要分为两大类：静态代理模式和动态代理模式，其中动态代理模式又可分为JDK动态代理和cglib动态代理，下面对各种代理模式做详细介绍。

静态代理模式

静态代理是简单代理模式，是由程序员编写的代理类，并在程序运行前就编译好的，而非程序动态产生代理类，这就是所谓的静态。也就是说需要提前定义接口或者父类，目标对象与代理对象一起实现相同的接口或者是继承相同父类。

实例

系统有一个打印的目标类，但是每次操作打印时需要增加日志，而添加日志这个功能在打印这个目标类中不存在，因此可以通过代理类在实现打印的同时增加日志功能。
代码如下：

/**
 * @Author: dong
 * @Project: DesignPatterns
 * @Description: 抽象的打印接口
 * @Date: Created in 下午11:04 2018/7/21
 * @Modified By:
 */
public interface Print {
    public void print();
}

/**
 * @Author: dong
 * @Project: DesignPatterns
 * @Description: 目标类
 * @Date: Created in 下午11:07 2018/7/21
 * @Modified By:
 */
public class PrintReal implements Print {
    @Override
    public void print() {
        System.out.println("print...");
    }
}

/**
 * @Author: dong
 * @Project: DesignPatterns
 * @Description: 代理类
 * @Date: Created in 下午11:04 2018/7/21
 * @Modified By:
 */
public class PrintProxy implements Print {
    private PrintReal print;
    public PrintProxy(PrintReal print){
        super();
        this.print = print;
    }
    @Override
    public void print() {
        System.out.println("log：XXX在YYY时间开始打印...");
        print.print();
        System.out.println("log：XXX在MMM时间结束打印...");
    }
}

/**
 * @Author: dong
 * @Project: DesignPatterns
 * @Description: 测试类
 * @Date: Created in 下午11:20 2018/7/21
 * @Modified By:
 */
public class TestProxy {
    public static void main(String[] args) {
        PrintReal printReal = new PrintReal();
        Print print = new PrintProxy(printReal);
        print.print();
    }
}

总结：

优点是：可以做到在不修改目标对象的功能前提下，对目标功能扩展。
缺点是：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类，同时，一旦接口增加方法，目标对象与代理对象都要维护。

动态代理

代理类在程序运行时创建的代理方式被成为动态代理。上例中的PrintProxy在程序运行之前就已经编译完成。然而动态代理，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。
动态代理扩展了静态代理的不足，例如有多个目标类，其中需要的扩展方法差不多一致，即仅调用的目标类不同。也就是说，多个目标类对应一个代理类，共享拓展功能，动态调用所需主题，这样可以大大减小了程序规模，这就是动态代理模式的特点。

JDK动态代理

JDK中生成代理对象的API，JDK实现代理需要使用newProxyInstance方法：

static Object newProxyInstance(ClassLoader loader, Class[] interfaces,InvocationHandler h )；

该方法是在Proxy类中是静态方法,且接收的三个参数依次为:
ClassLoader loader:指定当前目标对象使用类加载器，获取加载器的方法是固定的。
Class[] interfaces：目标对象实现的接口的类型，使用泛型方式确认类型。
InvocationHandler：指定动态处理器，执行目标对象的方法时,会触发事件处理器的方法。

具体过程如下：
1、定义一个事件管理器类实现invocationHandle接口,并重写invoke（代理类，被代理的方法，方法的参数列表）方法；
2、实现被代理类及其实现的接口；
3、调用Proxy的静态方法newProxyInstance(类加载器，类实现的接口，事务处理器对象)，生成一个代理实例；
4、通过该代理实例调用方法。
代码如下：

/**
 * @Author: dong
 * @Project: DesignPatterns
 * @Description: 抽象的打印接口
 * @Date: Created in 下午11:34 2018/7/21
 * @Modified By:
 */
public interface Print {
    public void print();
}


/**
 * @Author: dong
 * @Project: DesignPatterns
 * @Description: 目标类
 * @Date: Created in 下午11:37 2018/7/21
 * @Modified By:
 */
public class PrintReal implements Print {
    @Override
    public void print() {
        System.out.println("print...");
    }
}


/**
 * @Author: dong
 * @Project: DesignPatterns
 * @Description:
 * @Date: Created in 下11:40 2018/7/21
 * @Modified By:
 */
public class ProxyPrint implements InvocationHandler {
    private Object target;
    public ProxyPrint(Object object) {
        super();
        this.target = object;
    }
    /**
     * @des
     * @param proxy 被代理的对象
     * @param method 被代理对象的方法
     * @param args 方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("log：XXX在YYY时间开始打印...");
        Object result = method.invoke(target, args);
        System.out.println("log：XXX在MMM时间结束打印...");
        return result;
    }
}


/**
 * @Author: dong
 * @Project: DesignPatterns
 * @Description:
 * @Date: Created in 下午11:45 2018/7/21
 * @Modified By:
 */
public class TestJDKProxy {
    public static void main(String[] args) {
        PrintReal printReal = new PrintReal();
        ProxyPrint proxyPrint = new ProxyPrint(printReal);
        ClassLoader classLoader = printReal.getClass().getClassLoader();
        Print print = (Print) Proxy.newProxyInstance(classLoader, printReal.getClass().getInterfaces(), proxyPrint);
        print.print();
    }
}