设计模式-代理模式

代理模式（Proxy Pattern）是一个使用率非常高的模式，其定义为： 为其他对象提供一种代理以控制对这个对象的访问。代理模式也叫委托模式。
代理模式通用类图：

类图中的三个角色的定义：

• Subject抽象主题角色

抽象主题类可以是抽象类也可以是接口，是一个最普通的业务类型定义。

• RealSubject具体主题角色

也叫做被委托角色、被代理角色。是业务逻辑的具体执行者。

• Proxy代理主题角色

也叫做委托类、代理类。它负责对真是角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作。

/**
 * 抽象主题类
 */
public interface Subject {
    /**
     * 定义一个方法
     */
    public void request();
}

/**
 * 真实主题类
 */
public class RealSubject implements Subject {
    /**
     * 实现方法
     */
    @Override
    public void request() {
        //业务逻辑处理
    }
}

/**
 * 代理类
 */
public class Proxy implements Subject {
    //要代理哪个实现类
    private Subject subject = null;

    //默认被代理者
    public Proxy() {
        this.subject = new Proxy();
    }

    //通过构造函数传递代理者
    public Proxy(Object... objects) {

    }

    @Override
    public void request() {
        this.before();
        this.subject.request();
        this.after();
    }

    //预处理
    private void before() {
        //do something
    }

    //善后处理
    private void after() {
        //do something
    }
}

• JDK动态代理

import java.lang.reflect.*;

/**
 * JDK动态代理
 */
public class DynamicProxy implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(target, args);
        after();
        return result;
    }

    private void before() {
        //do something
    }

    private void after() {
        //do something
    }

    @SuppressWarnings("unchecked")
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }

    /**
     * 测试demo
     * @param args
     */
    public static void main(String[] args){
        DynamicProxy dynamicProxy = new DynamicProxy(new RealSubject());
        Subject subject = dynamicProxy.getProxy();
        subject.request();
    }
}

• CGlib动态代理

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * CGlib动态代理
 */
public class CGLibProxy implements MethodInterceptor {
    private static CGLibProxy instance = new CGLibProxy();

    private CGLibProxy() {

    }

    public static CGLibProxy getInstance() {
        return instance;
    }

    public <T> T getProxy(Class<T> cls) {
        return (T) Enhancer.create(cls, this);
    }

    private void before() {
        //do something
    }

    private void after() {
        //do something
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object result = methodProxy.invokeSuper(o, objects);
        after();
        return result;
    }

    /**
     * 测试demo
     * @param args
     */
    public static void main(String[] args) {
        CGLibProxy cgLibProxy = new CGLibProxy();
        Subject subject = cgLibProxy.getProxy(RealSubject.class);
        subject.request();
    }
}

参考文献：
《设计模式之禅（第2版）》
《架构探险 从零开始写javaweb框架》