代理模式

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

代理类和被代理类实现相同的接口(或继承同一个抽象类)

public interface ISubject {
    void a();
    void b();
}
public class ConcreteSubject implements ISubject{
    @Override
    public void a() {
    }
    @Override
    public void b() {
    }
}
public class Proxy implements ISubject{
    private ISubject iSubject;
    public Proxy(ISubject iSubject) {
        this.iSubject = iSubject;
    }
    @Override
    public void a() {
        this.before();
        iSubject.a();
        this.after();
    }
    @Override
    public void b() {
        this.before();
        iSubject.b();
        this.after();
    }
    private void before(){
    }
    private void after(){
    }
}

强制代理：从真实对象访问代理对象

动态代理：通过反射生成代理类
静态代理需要手动创建代理类和手动实现代理方法，而动态代理可以动态的自动生成代理类和实现代理方法

1. jdk动态代理，实现invocationHandler接口
2. cglib动态代理

动态代理和静态代理
（1）静态代理只能通过手动完成代理操作，如果被代理类增加了新的方法，则代理类需要同步增加，违背开闭原则。
（2）动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则。
（3）若动态代理要对目标类的增强逻辑进行扩展，结合策略模式，只需要新增策略类便可完成，无须修改代理类的代码。

jdk动态代理

public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;
    public Object getTarget() {
        return target;
    }
    public void setTarget(Object target) {
        this.target = target;
    }
    //动态生成代理类
    Object getProxy(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }
    //动态调用代理方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        //jdk序列化是通过method对象反射调用的
        Object result = method.invoke(target,args);
        after();
        return result;
    }
    private void before(){
        System.out.println("before");
    }
    private void after(){
        System.out.println("after");
    }
}
public class Client {
    public static void main(String[] args){
        ISubject subject = new ConcreteSubject();
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        //设置被代理对象
        proxyInvocationHandler.setTarget(subject);
        //动态生成代理对象
        ISubject proxy = (ISubject) proxyInvocationHandler.getProxy();
        //调用方法
        proxy.a();
    }
}

jdk动态代理采用字节码重组，重新生成对象代替原始对象。
（1）获取被代理对象的引用，并且获取它的所有接口，反射获取。
（2）JDK动态代理类重新生成一个新的类，同时新的类要实现被代理类实现的所有接口。
（3）动态生成Java代码，新加的业务逻辑方法由一定的逻辑代码调用（在代码中体现）。
（4）编译新生成的Java代码.class文件。
（5）重新加载到JVM中运行。
ClassPath以$开头的.class文件是自动生成的，jdk动态代理生成的代理类需要实现被代理类的所有接口(也就是说被代理的类至少需要实现一个接口，没有实现接口的类不能进行jdk动态代理)

proxyclass在第一次生成代理对象的时候由ProxyClassFactory构建，然后放入缓存中，后续生成代理对象的时候直接从缓存获取

cglib动态代理
cglib动态代理通过动态继承目标对象实现动态代理，覆盖父类方法(也就是说cglib不能代理final的方法)
MethodInterceptor

import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CGLibInterceptor implements MethodInterceptor {
    public Object getProxy(Class<?> clazz){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object object = methodProxy.invokeSuper(o,objects);
        after();
        return object;
    }
    private void before(){
        System.out.println("before");
    }
    private void after(){
        System.out.println("after");
    }
}

CGlib生成三个.class，其中fastClass会在第一次调用invoke()或者invokeSuper()的时候通过反射创建，然后放入缓存中

• 代理类
• 代理类的fastClass
• 被代理类的fastClass

fastClass为每一个代理类/被代理类的方法分配一个index，调用invoke的时候，根据index直接定位到要调用的方法并进行调用，不需要经过反射。也就是说，jdk动态代理的每次invoke都需过Method对象反射调用，而cglib动态代理的invoke方法有一个switch(index) case的操作

cglib中的.class文件
public Object invoke(int i,Object obj,Object[] args){
    siwtch(i){
        case 0:
            goto _L1;break;
        case 1:
            goto _L2;break;
        ...
    _L1:
        a();
        return null;
    _L1:
        b();
        return null; 
    }    
}

存储fastClass的缓存

package org.springframework.cglib.proxy;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.springframework.cglib.core.AbstractClassGenerator;
import org.springframework.cglib.core.CodeGenerationException;
import org.springframework.cglib.core.GeneratorStrategy;
import org.springframework.cglib.core.NamingPolicy;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.reflect.FastClass;
/**
 * Classes generated by {@link Enhancer} pass this object to the
 * registered {@link MethodInterceptor} objects when an intercepted method is invoked. It can
 * be used to either invoke the original method, or call the same method on a different
 * object of the same type.
 * @version $Id: MethodProxy.java,v 1.16 2009/01/11 20:09:48 herbyderby Exp $
 */
@SuppressWarnings({"rawtypes", "unchecked"})
public class MethodProxy {
    private Signature sig1;
    private Signature sig2;
    private CreateInfo createInfo;
    private final Object initLock = new Object();
    private volatile FastClassInfo fastClassInfo;
    /**
     * For internal use by {@link Enhancer} only; see the {@link org.springframework.cglib.reflect.FastMethod} class
     * for similar functionality.
     */
    public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
        MethodProxy proxy = new MethodProxy();
        proxy.sig1 = new Signature(name1, desc);
        proxy.sig2 = new Signature(name2, desc);
        proxy.createInfo = new CreateInfo(c1, c2);
        return proxy;
    }
    private void init() {
        /*
         * Using a volatile invariant allows us to initialize the FastClass and
         * method index pairs atomically.
         *
         * Double-checked locking is safe with volatile in Java 5.  Before 1.5 this
         * code could allow fastClassInfo to be instantiated more than once, which
         * appears to be benign.
         */
        //用dcl保证只在init的时候创建，并且只创建一次，volatile禁用指令重排序，不会使fastClassInfo没进行初始化就被使用
        if (fastClassInfo == null) {
            synchronized (initLock) {
                if (fastClassInfo == null) {
                    CreateInfo ci = createInfo;
                    FastClassInfo fci = new FastClassInfo();
                    fci.f1 = helper(ci, ci.c1);
                    fci.f2 = helper(ci, ci.c2);
                    fci.i1 = fci.f1.getIndex(sig1);
                    fci.i2 = fci.f2.getIndex(sig2);
                    fastClassInfo = fci;
                    createInfo = null;
                }
            }
        }
    }
    private static class FastClassInfo {
        FastClass f1;
        FastClass f2;
        int i1;
        int i2;
    }
    //创建fastclass
    private static FastClass helper(CreateInfo ci, Class type) {
        FastClass.Generator g = new FastClass.Generator();
        g.setType(type);
        // SPRING PATCH BEGIN
        g.setContextClass(type);
        // SPRING PATCH END
        g.setClassLoader(ci.c2.getClassLoader());
        g.setNamingPolicy(ci.namingPolicy);
        g.setStrategy(ci.strategy);
        g.setAttemptLoad(ci.attemptLoad);
        return g.create();
    }
    private MethodProxy() {
    }
    /**
     * Invoke the original method, on a different object of the same type.
     * @param obj the compatible object; recursion will result if you use the object passed as the first
     * argument to the MethodInterceptor (usually not what you want)
     * @param args the arguments passed to the intercepted method; you may substitute a different
     * argument array as long as the types are compatible
     * @throws Throwable the bare exceptions thrown by the called method are passed through
     * without wrapping in an <code>InvocationTargetException</code>
     * @see MethodInterceptor#intercept
     */
    public Object invoke(Object obj, Object[] args) throws Throwable {
        try {
            init();
            FastClassInfo fci = fastClassInfo;
            return fci.f1.invoke(fci.i1, obj, args);
        }
        catch (InvocationTargetException ex) {
            throw ex.getTargetException();
        }
        catch (IllegalArgumentException ex) {
            if (fastClassInfo.i1 < 0)
                throw new IllegalArgumentException("Protected method: " + sig1);
            throw ex;
        }
    }
    /**
     * Invoke the original (super) method on the specified object.
     * @param obj the enhanced object, must be the object passed as the first
     * argument to the MethodInterceptor
     * @param args the arguments passed to the intercepted method; you may substitute a different
     * argument array as long as the types are compatible
     * @throws Throwable the bare exceptions thrown by the called method are passed through
     * without wrapping in an <code>InvocationTargetException</code>
     * @see MethodInterceptor#intercept
     */
    public Object invokeSuper(Object obj, Object[] args) throws Throwable {
        try {
            init();
            FastClassInfo fci = fastClassInfo;
            return fci.f2.invoke(fci.i2, obj, args);
        }
        catch (InvocationTargetException e) {
            throw e.getTargetException();
        }
    }
}

框架：
spring aop
JdkDynamicAopProxy类和CglibAopProxy类

• 当bean实现了接口，使用jdk动态代理
• bean没有实现接口，使用cglib动态代理
• 使用可以强制使用cglib动态代理

Mybatis的MapperProxyFactory

MapperProxyFactory生成MapperProxy和代理对象，代理对象(Mapper)调用方法，从缓存中获取MapperMethod对象，MapperMethod调用excute方法，SqlSession的成员变量SqlCommand记录了sql的类型，MedthodSignature解析将参数值转换为Map＜Key，Value＞的映射，Key是方法的参数名称，Value是参数值。Configuration保存sql语句。

代理模式的优点
（1）代理模式能将代理对象与真实被调用目标对象分离。
（2）在一定程度上降低了系统的耦合性，扩展性好。
（3）可以起到保护目标对象的作用。
（4）可以增强目标对象的功能。

代理模式的缺点
（1）代理模式会造成系统设计中类的数量增加。
（2）在客户端和目标对象中增加一个代理对象，会导致处理请求的速度变慢。
（3）增加了系统的复杂度。