代理模式（Proxy）

代理模式和装饰模式非常类似，甚至代码都类似。二者最主要的区别是：代理模式中，代理类对被代理的对象有控制权，决定其执行或者不执行。而装饰模式中，装饰类对代理对象没有控制权，只能为其增加一层装饰，以加强被装饰对象的功能。我们日常看到的mybatis分页插件，以及日志拦截、事务拦截、权限拦截这些几乎全部由动态代理的身影。代理模式使用到极致开发就是AOP，这是各位采用Spring架构开发必然要使用到的技术，它就是使用了代理和反射的技术，后续会讲到。

UML图

UML.png

静态代理和动态代理
代理分为静态代理和动态代理，静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成，但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的重复代码，此时我们就可以采用动态代理，动态代理可以在程序运行期间根据需要动态的创建代理类及其实例，来完成具体的功能。

代码实现--静态代理

/**
* 接口
*/
public interface Subject {

    void request();

    void hello();
}

/**
* 接口的真实实现类
*/
public class RealSubject implements Subject {

    @Override
    public void request(){
        System.out.println("From Real Subject");
    }

    @Override
    public void hello() {
        System.out.println("hello world");
    }
}

/**
* 代理类
*/
public class ProxySubject implements Subject {

    RealSubject subject = new RealSubject();

    @Override
    public void request() {
        System.out.println("静态代理前置内容");
        subject.request();
        System.out.println("静态代理后置内容");
    }

    @Override
    public void hello() {
        System.out.println("静态代理前置内容");
        subject.hello();
        System.out.println("静态代理后置内容");
    }
}

/**
* 测试类
*/
public class Test {

    public static void main(String[] args) {
        
        ProxySubject proxySubject = new ProxySubject();
        
        proxySubject.hello();

        System.out.println("------------");
        
        proxySubject.request();
    }
}

运行结果
静态代理前置内容
hello world
静态代理后置内容

---

静态代理前置内容
From Real Subject
静态代理后置内容

代码实现--动态代理
JDK动态代理

public interface Subject {

    void hello();

}

public class SubjectImpl implements Subject {
    @Override
    public void hello() {
        System.out.println("hello world");
    }
}

public class MyInvocationHandler implements InvocationHandler {

    private Object object;

    public Object setProxy(Object o) {
        this.object = o;
        return Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("begin jdkProxy");

        Object object = method.invoke(this.object, args);

        System.out.println("end jdkProxy");

        return object;
    }

}

public class Client {

    public static void main(String[] args) {
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();

        Subject subject = (Subject) myInvocationHandler.setProxy(new SubjectImpl());

        subject.hello();
    }
}

Cglib动态代理

public class Target {

    public void eat() {
        System.out.println("I am eating");
    }

    public String hello(String name) {
        System.out.println("hello");
        return "hello " + name;
    }
}

public class Interceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println("begin cglib proxy");

        Object object = methodProxy.invokeSuper(o, objects);

        System.out.println("end cglib proxy");

        return object;
    }
}

public class Client {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer(); //字节码增强器
        enhancer.setCallback(new Interceptor()); //设置回调
        enhancer.setSuperclass(Target.class); //设置被代理类为父类

        Target target = (Target) enhancer.create(); //创建代理实例
        target.eat();
        target.hello("world");

    }
}

总结一下
JDK动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

Spring在使用两种动态代理时的机制
1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP
3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

如何强制使用CGLIB实现AOP？
（1）添加CGLIB库，SPRING_HOME/cglib/*.jar
（2）在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>

JDK动态代理和CGLIB字节码生成的区别？
（1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类
（2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法， 因为是继承，所以该类或方法最好不要声明成final

源码分析详解参考以下两篇文章：
JDK动态代理源码分析详解
Cglib动态代理源码分析详解