一、前言
Spring中的AOP思想就是对代理模式的经典运用，下面先讲讲代理模式的核心思想，以静态代理为例。
二、示例
下面有这样一个例子，委托人在遭遇利益受损的时候，可以委托律师帮忙打官司。
先定义一个描述行为的接口：
package com.design.proxy.statics;
public interface Action {
void handle();
}
委托人，实现这个接口，主要的行为是寻找律师。
package com.design.proxy.statics;
/**
* 委托人
*/
public class Client implements Action {
@Override
public void handle() {
System.out.println("委托人：我要找律师,帮我打官司");
}
}
律师类，同样实现这个接口，并且持有一个委托人的引用，可以帮助委托人打官司。
package com.design.proxy.statics;
/**
* 律师
*/
public class Lawyer implements Action {
private Action action;
public Lawyer(Action action) {
this.action = action;
}
@Override
public void handle() {
action.handle();
System.out.println("律师：帮助我的委托人打官司");
}
}
Main类，用来描述打官司的过程
package com.design.proxy.statics;
public class Main {
public static void main(String[] args) {
Action client = new Client();
Action lawyer = new Lawyer(client);
lawyer.handle();
}
}
输出如下：
这就是代理模式的一个运用，这里的委托人显然是被代理对象，那么律师就是代理对象，律师代理委托人进行打官司。
三、类图
代理模式的类图如下：
- Subject 抽象主题对象，是代理对象以及被代理对象都需要实现的接口或继承的类
- Proxy 被代理对象，持有被代理对象的一个引用，控制被代理对象的行为以及访问
- RealSubject 被代理对象，定义具体的逻辑实现。
代理又分为静态代理与动态代理，在上个例子中，就是一个典型的静态代理。静态代理与动态代理的区别就在于，静态代理的.class文件在程序运行前就已经存在了，而动态代理的.class文件则是利用反射机制动态生成的。
在静态代理中，静态代理对象=实现一个与被代理对象相同的接口+增强方法。
四、动态代理
在上一节已经说过，动态代理是在程序运行时，动态生成代理类。动态代理又分为JDK动态代理与CGLIB动态代理。
JDK动态代理
我们现在在Action类中增加更多的行为，代表委托人的需求。
package com.design.proxy.statics;
public interface Action {
/**
* 诉讼
*/
void litigation();
/**
* 咨询
*/
void consult();
//...
}
那么委托人：
package com.design.proxy.statics;
/**
* 委托人
*/
public class Client implements Action {
@Override
public void litigation() {
System.out.println("委托人：我有诉讼的需求");
}
@Override
public void consult() {
System.out.println("委托人：我有咨询的需求");
}
}
在动态代理中，就不需要一个真实的代理对象了，代理对象是在运行时动态生成的。JDK提供了一种思路，实现InvocationHandler接口，并通过Proxy.newProxyInstance获取动态生成的代理对象。
package com.design.proxy.dynamic.jdk;
import com.design.proxy.statics.Action;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class LawyerHandler implements InvocationHandler {
private Action action;
//绑定被代理对象，最后返回代理对象的实例
public Action bind(Action action) {
this.action = action;
return (Action) Proxy.newProxyInstance(
action.getClass().getClassLoader(),
action.getClass().getInterfaces(),
this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//调用被代理对象的方法
Object o = method.invoke(action, args);
//增强方法
System.out.println("律师处理委托人的需求");
return o;
}
}
Main类：
package com.design.proxy.dynamic.jdk;
import com.design.proxy.statics.Action;
import com.design.proxy.statics.Client;
public class Main {
public static void main(String[] args) {
Action action = new LawyerHandler().bind(new Client());
action.litigation();
action.consult();
}
}
输出如下：
动态代理的核心，在于怎么获取动态代理对象，也就是怎么去获取动态代理对象的class对象，而要获取一个类的class对象，需要类加载器与一个.class文件，类加载器由action.getClass().getClassLoader()提供。
对类加载器不熟悉的同学，可以参考我的另外一篇文章类加载器与双亲委派模型
.class文件由java类编译形成，也就是说现在需要一个动态代理类的java文件内容，由静态代理的类结构可以得出，这个动态代理类同样需要实现与被代理类相同的接口，这个接口由action.getClass().getInterfaces()提供。
动态代理类同样需要持有被代理对象的引用，方便在增强方法中调用被代理对象的方法，这个（增强方法+被代理对象的引用+调用被代理对象方法）的组合，由InvocationHandler中的invoke方法提供。内部的method.invoke(action, args)方法，就是去调用被代理对象(action)的方法(method)，方法参数为args。
如果我们使用静态代理来处理上面这个例子，则需要新建律师类，实现Action接口，实现接口中所有的方法，并在这些方法中去做同样的增强逻辑，代码冗余度高。如果有很多类需要代理，也或造成代理类的膨胀。
CGLIB动态代理
JDK动态代理，需要被代理类实现某个接口，如果该类没有实现接口，则无法使用JDK动态代理，此时可以使用CGLIB动态代理。
CGLIB是一个第三方实现的动态代理，需要引入cglib与asm的jar包，这个去maven仓库一搜就能搜到。
我们重新改造委托人这个类，添加一个final方法
package com.design.proxy.dynamic.cglib;
/**
* 委托人
*/
public class Client {
public void litigation() {
System.out.println("委托人：我有诉讼的需求");
}
public void consult() {
System.out.println("委托人：我有咨询的需求");
}
public final void renting() {
System.out.println("委托人：我有租房的需求");
}
}
CGLIB同样需要我们实现MethodInterceptor类
package com.design.proxy.dynamic.cglib;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class LawyerInterceptor implements MethodInterceptor {
private Object object;
public Object getInstance(Object object) {
this.object = object;
//Cglib中的加强器，用来创建动态代理
Enhancer enhancer = new Enhancer();
//设置代理类的父类
enhancer.setSuperclass(this.object.getClass());
//设置回调，这里相当于是对于代理类上所有方法的调用，都会调用Callback，而Callback则需要实现intercept()方法进行拦截
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
Object object = proxy.invokeSuper(obj, args);
System.out.println("律师处理委托人的需求");
return object;
}
}
Main类：
package com.design.proxy.dynamic.cglib;
public class Main {
public static void main(String[] args) {
Client client = (Client) new LawyerInterceptor().getInstance(new Client());
client.litigation();
client.consult();
client.renting();
}
}
输出得到：
CGLIB动态代理，依据被代理类生成其对应的子类，子类就是代理类，即在子类中覆盖所有可被继承的方法，并在重写方法中对被代理类进行增强。
委托人这个类中，由于renting方法是个final方法，无法被子类继承，因此也无法被增强。
CGLIB动态代理最为核心的地方在于Enhancer，使用setSuperclass指明被代理类继承什么类，当调用父类中的方法时，将会触发回调，回调将会触发MethodInterceptor 中的intercept方法，在intercept方法中保存了被增强方法调用的时机。
