设计模式--代理模式（Proxy Pattern）

1、定义
代理模式就是为其他对象提供一种代理以控制对这个对象的访问。主要分为两种代理模式：静态代理和动态代理。

• 静态代理：利用组合关系实现静态代理，组合关系注入源对象，然后可以在外层对象进行其它逻辑的注入。静态代理的问题是不同的逻辑注入需要不同的代理对象，一直增加代理对象显然不实际。
• 动态代理：在java中，可以直接利用java.lang.refect.Proxy类直接创建代理类或者代理对象。

2、代理模式结构
所谓的代理，就是一个人或者一个机构代表另外一个人或者另外一个机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象中间起到中介的作用。

代理模式的类图如下：

代理模式中的角色有：

• 抽象对象角色（Abstract Object）：声明了目标对象和代理对象的共同接口，这样依赖在任何可以使用目标对象的地方都可以使用代理对象。
• 目标对象角色(Real Object)：定义了代理对象所代表的目标对象。
• 代理对象角色(Proxy Object)：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或者之后，执行某个操作，而不是单纯的将调用传递给目标对象。

3、静态代理
静态代理中，一个目标对象对应一个代理对象，代理类在编译时期就已经确定了。

抽象对象角色：

public abstract class AbstractObject {
    public abstract void operation();
}

目标对象角色：

public class RealObject extends AbstractObject {
    public void operation() {
        System.out.println("Do Something!");
    }
}

代理对象角色：

public class ProxyObject extends AbstractObject {
    RealObject realObject = new RealObject();
    public void operation() {
        //在调用目标对象之前，完成一些操作
        System.out.println("Before Do Something");
        realObject.operation();
        //在调用目标对象之后，完成一些操作
        System.out.println("After Do Something");
    }
}

静态代理模式简单易用，可以做到在不修改目标对象的前提下，拓展目标对象的功能。但是如果要代理多个接口，需要创建多个的代理对象，并且，一旦接口中增加方法，目标对象同代理对象都需要进行维护。

4、动态代理
动态代理主要有如下特点：

• 代理对象不需要实现目标对象的接口。
• 代理对象的生成，使用的是Java的API，动态的在内存中构件代理对象(这需要我们指定创建代理对象/目标对象的接口的类型)。
• 动态代理也叫做JDK代理、接口代理。

4.1、JDK动态代理
JDK 动态代理是利用 Proxy类 的 newProxyInstance 方法创建代理对象，通过反射调用被代理对象的方法。

目标对象接口：

public interface IUserDao {
    void save();
}

目标对象类：

public class UserDao implements IUserDao {
    @Override
    public void save() {
        System.out.println("已经保存数据！！！");
    }
}

动态代理对象：

public class ProxyFactory {

    /**
     * 维护一个目标对象
     */
    private Object target;

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

    public Object getProxyInstance() {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("before...");
                        Object invoke = method.invoke(target, args);
                        System.out.println("after...");
                        return invoke;
                    }
                }
        );
    }
}

动态代理对象不需要实现目标对象的接口，解决了静态代理每个接口一个代理类的问题，但是JDK动态代理是面向接口的，所以目标对象一定要实现接口，否则不能实现动态代理。

4.2、CGLIB代理
静态代理和JDK动态代理模式都需要目标对象是一个实现了接口的对象，但是有的时候，目标对象可能只是一个单独的对象，并没有实现任何的接口，这个时候，我们就可以使用目标对象子类的方式实现代理，这种代理方式就是：Cglib代理。

CGLIB代理也叫子类代理，它是在内存中构件一个子类对象，从而实现对目标对象的功能拓展。

目标对象类：

public class UserDao {
    public void save() {
        System.out.println("--------已经保存数据--------");
    }
}

Cglib代理工厂类：

public class ProxyFactory implements MethodInterceptor {
    //维护目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //获取目标对象的代理对象
    public Object getProxyInstance() {
        //1. 实例化工具类
        Enhancer en = new Enhancer();
        //2. 设置父类对象
        en.setSuperclass(this.target.getClass());
        //3. 设置回调函数
        en.setCallback(this);
        //4. 创建子类，也就是代理对象
        return en.create();
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("Begin Transaction");

        //执行目标对象的方法
        Object returnValue = method.invoke(target, objects);

        System.out.println("End Transaction");

        return returnValue;
    }
}

CGLIB 代理的对象不能为 final 的。
目标对象的方法如果为final/static修饰的，那么就不会被拦截，即不会执行目标对象额外的方法。

参考：Java设计模式-代理模式