动态代理：JDK原生动态代理（Java Proxy）和CGLIB动态代理原理+附静态态代理
本文只是对原文的梳理总结，以及自行理解。自己总结的比较简单，而且不深入，不如直接看原文。不过自己梳理一遍更有助于理解。
详细可参考原文：http://www.cnblogs.com/CarpenterLee/p/8241042.html （原文很强大，多看几遍，深入理解。）
原文中参考：https://www.jianshu.com/p/e2917b0b9614 （比原文的代码更详细，更有助于理解）
自行总结：
- 两种代理方式，都是提供一个方法调用的中转站用于实现代理：CGLIG中MethodInterceptor和跟JDK代理中的InvocationHandler；
- 都是通过特定类的特定方法得到代理对象：
- Proxy.newProxyInstance() 方法入参中包含：类加载器（被代理对象的）、代理需要实现的接口，可以有多个（被代理对象的）、方法调用的实际处理者（即实际代理对象）
- Enhancer.create() 方法入参中包含：Superclass （被代理的类） 和 Callback （代理类）
- 调用代理对象的对应方法，会自动被代理到 invoke() 方法和 intercept() 方法。可在方法中加入代理的逻辑
- 最终还需要调用实际被代理对象的方法：Method. invoke() 和 MethodProxy.invokeSuper() 。
一、静态代理的实现
- 声明接口；
- 编码接口实现类，需继承对应接口，实现对应方法；
- 编码代理类，需继承对应接口，实现对应方法。代理类内部方法实际调用具体实现类的方法，同时加入额外逻辑。
具体实现可参考原文。
二、JDK原生动态代理：基于接口
1、动态代理：实际就是JDK定义类和方法（Proxy.newProxyInstance()），我们只需传入相关入参，JDK会自行为我们创建代理类，以实现代理功能。
2、使用实现：
// Java Proxy
// 1. 首先实现一个InvocationHandler，方法调用会被转发到该类的invoke()方法。
class LogInvocationHandler implements InvocationHandler{
...
private Hello hello;
public LogInvocationHandler(Hello hello) {
this.hello = hello;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if("sayHello".equals(method.getName())) {
logger.info("You said: " + Arrays.toString(args));
}
return method.invoke(hello, args);
}
}
// 2. 然后在需要使用Hello的时候，通过JDK动态代理获取Hello的代理对象。
Hello hello = (Hello)Proxy.newProxyInstance(
getClass().getClassLoader(), // 1. 类加载器（被代理对象的）
new Class<?>[] {Hello.class}, // 2. 代理需要实现的接口，可以有多个（被代理对象的）
new LogInvocationHandler(new HelloImp()));// 3. 方法调用的实际处理者（即实际代理对象）
System.out.println(hello.sayHello("I love you!"));
3、具体使用总结：
- 首先实现一个InvocationHandler，方法调用会被转发到该类的invoke()方法。invoke() 方法就是实际的代理方法。
- 需要使用Hello时，通过JDK动态代理获取Hello的代理对象。
- 调用代理对象的接口声明方法，会被自动转发到invoke()方法上。
4、上述代码理解：
关键是：Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler)方法
该方法会根据指定的参数动态创建代理对象。三个参数的意义如下：
loader，指定代理对象的类加载器；
interfaces，代理对象需要实现的接口，可以同时指定多个接口；
handler，方法调用的实际处理者，代理对象的方法调用都会转发到这里（*注意1）。
newProxyInstance()会返回一个实现了指定接口的代理对象，对该对象的所有方法调用都会转发给InvocationHandler.invoke()方法。
理解上述代码需要对Java反射机制有一定了解。动态代理神奇的地方就是：
-代理对象是在程序运行时产生的，而不是编译期；
-对代理对象的所有接口方法调用都会转发到InvocationHandler.invoke()方法，在invoke()方法里我们可以加入任何逻辑，比如修改方法参数，加入日志功能、安全检查功能等；之后我们通过某种方式执行真正的方法体，示例中通过反射调用了Hello对象的相应方法，还可以通过RPC调用远程方法。
5、其他理解：参考JDK官方文档即可
- InvocationHandler（接口）和其invoke()方法理解：
接口：
java.lang.reflect.InvocationHandler
方法：在代理实例上处理方法调用并返回结果。
Object invoke(Object proxy, Method method, Object[] args)
参数：
proxy - 在其上调用方法的代理实例（即代理对象）
method - 对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。（即代理方法）
args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。
返回：
从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException。否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。
- Proxy（类）的理解：
类：java.lang.reflect.Proxy
方法：返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
参数：
loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表
h - 指派方法调用的调用处理程序
返回：
一个带有代理类的指定调用处理程序（即入参：h ）的代理实例，它由指定的类加载器（即入参：loader）定义，并实现指定的接口（即入参：interfaces）
- 对于不同invoke()方法的理解：
java.lang.reflect.Method.invoke(Object, Object...)
对带有指定参数的指定对象调用由此 Method 对象表示的底层方法
//即该方法所属对象的该方法调用。
java.lang.reflect.InvocationHandler.invoke(Object, Method, Object[])
三、CGLIB动态代理
大致原理和JDK动态代理一致，方便使用。
优点在于：可以代理没有实现任何接口的类；
1、使用实现：
//需被代理的类
public class HelloConcrete {
public String sayHello(String str) {
return "HelloConcrete: " + str;
}
}
// CGLIB动态代理
// 1. 首先实现一个MethodInterceptor，方法调用会被转发到该类的intercept()方法。
class MyMethodInterceptor implements MethodInterceptor{
...
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
logger.info("You said: " + Arrays.toString(args));
return proxy.invokeSuper(obj, args);
}
}
// 2. 然后在需要使用HelloConcrete的时候，通过CGLIB动态代理获取代理对象。
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloConcrete.class); //被代理的类
enhancer.setCallback(new MyMethodInterceptor());//代理类
HelloConcrete hello = (HelloConcrete)enhancer.create(); //代理对象
System.out.println(hello.sayHello("I love you!"));
2、具体使用总结：
- 首先实现一个MethodInterceptor，方法调用会被转发到该类的intercept()方法。
- 然后在需要使用HelloConcrete的时候，设置参数，同时通过CGLIB动态代理获取代理对象。
- 调用代理对象的代理方法，然后会自行实现其调用
3、上述代码理解：
1、通过CGLIB的Enhancer来指定要代理的目标对象、实际处理代理逻辑的对象，
2、最终通过调用create()方法得到代理对象，对这个对象所有非final方法的调用都会转发给MethodInterceptor.intercept()方法，
3、在intercept()方法里我们可以加入任何逻辑，比如修改方法参数，加入日志功能、安全检查功能等；
4、通过调用MethodProxy.invokeSuper()方法，我们将调用转发给原始对象，具体到本例，就是HelloConcrete的具体方法。
CGLIG中MethodInterceptor的作用跟JDK代理中的InvocationHandler很类似，都是方法调用的中转站。