一、CGLIB动态代理
JDK动态代理要求被代理的类必须实现接口，有很强的局限性，而CGLIB动态代理则不要求被代理类实现接口。简单的说，CGLIB会让生成的代理类继承被代理类，并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。在CGLIB底层，其实是借助了ASM这个非常强大的Java字节码生成框架。Cglib无法代理被final修饰的方法。
cglib的原理是继承，cglib通过继承目标类，创建它的子类，在子类中重写父类中同名的方法，实现功能的修改。因为cglib是继承，重写方法，所以要求目标类不能是final的，方法也不能是final的。cglib的要求目标类比较宽松，只要能继承就可以了。cglib在很多的框架中使用，比如mybatis,spring框架中都有使用。
1、cglib动态代理的简单使用
使用CGLIB动态代理主要有以下几个步骤：
1.编写一个被代理类(也称委托类或目标类)，无需实现任何接口；
2.自定义一个方法拦截器，实现MethodInterceptor接口，并重写intercept方法；
3.在intercept方法中调用MethodProxy类的invokeSuper方法（而不是调用invoke方法，因为invoke会引起死循环，导致堆栈内存溢出，具体原因在下面会详细分析。在invokeSuper方法中，底层实际上最终会调用被代理类中相应的被代理方法）；
4.创建代理对象，并调用被代理类中的方法(实际上是调用代理对象中重写的代理方法)。
示例代码：
package com.tx.study.others.proxy.cglibProxy;
/**
* @Author: 倚天照海
* @Description: 被代理类
*/
public class InfoDemo {
//被代理方法(被final修饰的方法无法被代理)
public void welcome (String person){
System.out.println("welcome :" + person);
}
}
package com.tx.study.others.proxy.cglibProxy;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @Author: 倚天照海
* @Description: 自定义方法拦截器，实现MethodInterceptor接口，并重写intercept方法
*/
public class MyMethodInterceptor implements MethodInterceptor {
/**
* 重写intercept方法
*
* @param o 代理对象
* @param method 被代理方法对应的Method对象
* @param objects 被代理方法的参数
* @param methodProxy 方法代理对象
* @return 被代理方法的返回值
* @throws Throwable 可能会抛出的异常
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//在真实的对象执行之前可以添加自己的操作，插入前置通知
System.out.println("before method!!!");
//在invokeSuper方法中最终会调用被代理类中对应的被代理方法
Object value = methodProxy.invokeSuper(o, objects);
//会引起死循环，导致内存溢出
//Object value = methodProxy.invoke(o, objects);
//在真实的对象执行之后可以添加自己的操作，插入后置通知
System.out.println("after method!!!");
return value;
}
}
package com.tx.study.others.proxy.cglibProxy;
import org.springframework.cglib.core.DebuggingClassWriter;
import org.springframework.cglib.proxy.Enhancer;
/**
* @Author: 倚天照海
* @Description: cglib动态代理测试类
*/
public class CglibProxyTest {
/**
* 该方法的作用就是封装获取代理对象的代码，即获取代理对象
* @return 代理对象
*/
public static Object getProxyInstance() {
//Enhancer是CGLIB的字节码增强器，可以很方便的对类进行拓展
Enhancer enhancer = new Enhancer();
//为代理类设置父类，即代理类继承被代理类
enhancer.setSuperclass(InfoDemo.class);
//为代理类设置回调对象，即自定义的方法拦截器
enhancer.setCallback(new MyMethodInterceptor());
//创建代理对象
return enhancer.create();
}
public static void main(String[] args) {
//将代理类class文件存入本地磁盘，方便反编译查看源码
String path = "D:\\ProgramFiles\\workspace\\zznode\\data-query\\tx-study\\src\\main\\java\\com\\tx\\study\\others\\proxy\\cglibProxy\\";
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, path);
//获取代理对象
InfoDemo instance = (InfoDemo) getProxyInstance();
//调用被代理方法(底层会调用自定义方法拦截器中重写的intercept方法)
instance.welcome("zhangsan");
}
}
运行结果：
before method!!!
welcome :zhangsan
after method!!!
2、cglib动态代理的原理
原理分析：
执行测试类，会生成三个class文件，如下所示，通过反编译可以看到这三个文件中的源码。
InfoDemo$$EnhancerByCGLIB$$8b8da05b.class （cglib生成的代理类，继承InfoDemo类）
InfoDemo$$FastClassByCGLIB$$f4c7f3ac.class （被代理类的FastClass，记为f1）
InfoDemo$$EnhancerByCGLIB$$8b8da05b$$FastClassByCGLIB$$9065a6c.class （代理类的FastClass，记为f2）（在下面会详细说明这三个类的部分源码）
在MethodProxy类中有一个静态内部类FastClassInfo，如下所示。FastClassInfo中有四个属性，FastClass f1表示被代理类的FastClass，FastClass f2表示代理类的FastClass，int i1表示被代理类的方法签名(实际上是方法对应的索引，根据该索引可以快速找到对应的方法，这就是cglib动态代理比JDK动态代理效率高的主要原因)，int i2表示代理类的方法签名。通过FastClassInfo对象可以得到被代理类和代理类的FastClass，在下面会详细介绍。
private static class FastClassInfo {
FastClass f1;//被代理类的FastClass
FastClass f2;//代理类的FastClass
int i1; //被代理类的方法签名(index)
int i2;//代理类的方法签名
private FastClassInfo() {
}
}
先看一下本例中生成的代理类(InfoDemo$$EnhancerByCGLIB$$8b8da05b.class)的源码。
代理类InfoDemo$$EnhancerByCGLIB$$8b8da05b.class：
public class InfoDemo$$EnhancerByCGLIB$$8b8da05b extends InfoDemo implements Factory {
private MethodInterceptor CGLIB$CALLBACK_0; //拦截器
private static final Method CGLIB$welcome$0$Method; //被代理方法(是Method对象)
private static final MethodProxy CGLIB$welcome$0$Proxy; //方法代理(MethodProxy对象)
//..........................................省略
static void CGLIB$STATICHOOK1() {
CGLIB$THREAD_CALLBACKS = new ThreadLocal();
CGLIB$emptyArgs = new Object[0];
Class var0 = Class.forName("CglibTest.InfoDemo$$EnhancerByCGLIB$$8b8da05b");
Class var1;
//通过反射获取被代理方法
CGLIB$welcome$0$Method = ReflectUtils.findMethods(new String[]{"welcome", "(Ljava/lang/String;)V"}, (var1 = Class.forName("CglibTest.InfoDemo")).getDeclaredMethods())[0];
//生成与被代理方法对应的方法代理对象
CGLIB$welcome$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)V", "welcome", "CGLIB$welcome$0");
//..........................................省略
}
//cglib会生成与被代理方法对应的代理方法CGLIB$welcome$0
final void CGLIB$welcome$0(String var1) {
//直接调用父类的被代理方法(实际上被代理方法就是在此处被调用的)
super.welcome(var1);
}
//由于代理类继承了被代理类，所以在代理类中生成了被代理方法(进行了重写)
public final void welcome(String var1) {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if(this.CGLIB$CALLBACK_0 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
//判断代理类中是否设置了方法拦截，如果设置了就调用该拦截器的intercept方法
//在本例中设置了拦截器enhancer.setCallback(new MyMethodInterceptor());
if(var10000 != null) {
var10000.intercept(this, CGLIB$welcome$0$Method, new Object[]{var1}, CGLIB$welcome$0$Proxy);
} else {
//如果没有设置拦截器，就直接调用父类的被代理方法
super.welcome(var1);
}
}
//..........................................省略
}
在代理类中会生成与父类(即被代理类)中每一个方法相对应的两个方法，例如此例中父类的welcome方法，在代理类中生成了CGLIB$welcome$0代理方法和重写的welcome方法。另外，父类中的每一个方法都会在静态块中，通过MethodProxy.create生成对应的方法代理。
在本例测试类中，代理对象调用父类的被代理方法，即instance.welcome("zhangsan")，实际上调用的是代理类中被重写后的welcome方法，即public final void welcome(String var1)。在该方法中调用了拦截器MethodInterceptor的intercept方法。由于自定义的方法拦截器实现了MethodInterceptor接口，并对intercept方法进行了重写，所以，实际上调用的是重写后的intercept方法。在重写的intercept方法中调用了MethodProxy对象的invokeSuper(o, objects)方法，接下来重点看一下invokeSuper方法的执行过程，即分析MethodProxy的源码。
先看一下代理类中调用的intercept(this, CGLIB$welcome$0$Method, new Object[]{var1}, CGLIB$welcome$0$Proxy)方法，该方法中有四个参数，第一个参数是this，即调用代理类中重写后的welcome方法的对象，当然是代理对象了。第二个参数是被代理方法(实际上是Method对象)，第三个参数是被代理方法的参数数组，第四个参数是方法代理对象(即MethodProxy对象)。这四个参数也就是自定义方法拦截器的intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)方法中的四个参数。所以，methodProxy.invokeSuper(o, objects)方法中的methodProxy就是方法代理对象，o就是代理对象，objects就是被代理方法的参数。
MethodProxy 源码分析：
public class MethodProxy {
//下面的前三个变量在create方法中，都已经得到了初始值了。
private Signature sig1;
private Signature sig2;
private MethodProxy.CreateInfo createInfo;
//在调用invoke或者invokeSuper中，通过init()方法生成FastClassInfo
private volatile MethodProxy.FastClassInfo fastClassInfo;
public Object invokeSuper(Object obj, Object[] args) throws Throwable {
try {
this.init();
MethodProxy.FastClassInfo fci = this.fastClassInfo;
//调用代理类的FastClass的invoke方法
return fci.f2.invoke(fci.i2, obj, args);
} catch (InvocationTargetException var4) {
throw var4.getTargetException();
}
}
public Object invoke(Object obj, Object[] args) throws Throwable {
try {
this.init();
MethodProxy.FastClassInfo fci = this.fastClassInfo;
//调用被代理类的FastClass的invoke方法
return fci.f1.invoke(fci.i1, obj, args);
} catch (InvocationTargetException var4) {
throw var4.getTargetException();
} catch (IllegalArgumentException var5) {
if(this.fastClassInfo.i1 < 0) {
throw new IllegalArgumentException("Protected method: " + this.sig1);
} else {
throw var5;
}
}
}
//init方法就是为了生成FastClassInfo，FastClassInfo中存放着两个fastclass(f1、f2)和两个方法索引的值(i1、i2)。
private void init() {
if(this.fastClassInfo == null) {
Object var1 = this.initLock;
synchronized(this.initLock) {
if(this.fastClassInfo == null) {
MethodProxy.CreateInfo ci = this.createInfo;
MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo();
//不是每一个方法都生成一个fastclass，每一个方法的fastclass都是一样的，
//只不过他们的i1,i2不一样。如果缓存中有就取出，没有就生成新的FastClass
fci.f1 = helper(ci, ci.c1);
fci.f2 = helper(ci, ci.c2);
fci.i1 = fci.f1.getIndex(this.sig1);
fci.i2 = fci.f2.getIndex(this.sig2);
this.fastClassInfo = fci;
this.createInfo = null;
}
}
}
}
//根据一个类的信息，返回该对象的一个Fastclass
private static FastClass helper(MethodProxy.CreateInfo ci, Class type) {
Generator g = new Generator();
g.setType(type);
g.setClassLoader(ci.c2.getClassLoader());
g.setNamingPolicy(ci.namingPolicy);
g.setStrategy(ci.strategy);
g.setAttemptLoad(ci.attemptLoad);
return g.create();
}
//FastClassInfo是MethodProxy的静态内部类
private static class FastClassInfo {
FastClass f1;//被代理类的FastClass
FastClass f2;//代理类的FastClass
int i1; //被代理类的方法签名(index)
int i2;//代理类的方法签名
private FastClassInfo() {
}
}
}
在MethodProxy类的invokeSuper方法中调用了代理类的FastClass的invoke方法，接下来看一下代理类的FastClass的源码。代理类的FastClass的字节码反编译后的源码如下所示。
代理类的FastClass：
代理类的FastClass(InfoDemo$$EnhancerByCGLIB$$8b8da05b$$FastClassByCGLIB$$9065a6c)的字节码反编译后的源码：
public class InfoDemo$$EnhancerByCGLIB$$8b8da05b$$FastClassByCGLIB$$9065a6c extends FastClass {
public InfoDemo$$EnhancerByCGLIB$$8b8da05b$$FastClassByCGLIB$$9065a6c(Class var1) {
super(var1);
}
public int getIndex(Signature var1) {
String var10000 = var1.toString();
switch(var10000.hashCode()) {
case -2055565910:
if(var10000.equals("CGLIB$SET_THREAD_CALLBACKS([Lnet/sf/cglib/proxy/Callback;)V")) {
return 12;
}
break;
case -1725733088:
if(var10000.equals("getClass()Ljava/lang/Class;")) {
return 24;
}
case 1013143764:
if(var10000.equals("CGLIB$welcome$0(Ljava/lang/String;)V")) {
return 17;
}
}
//----省略
}
//在MethodProxy类的invokeSuper方法中调用了此处的invoke方法
public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
8b8da05b var10000 = (8b8da05b)var2;
int var10001 = var1;
try {
switch(var10001) {
case 0:
return var10000.toString();
case 1:
return new Integer(var10000.hashCode());
case 17:
//调用代理对象的代理方法CGLIB$welcome$0
var10000.CGLIB$welcome$0((String)var3[0]);
}
//----省略
}
}
}
由上述代码可知，在代理类的FastClass的invoke方法中调用了代理对象的CGLIB$welcome$0方法，由上面分析的代理类的源码可知，在代理类的CGLIB$welcome$0方法中直接调用父类的被代理方法，即调用此例中InfoDemo类的welcome方法，执行被代理方法。至此，cglib动态代理的大致过程就分析完毕了。
如果在自定义方法拦截器中调用的不是methodProxy.invokeSuper(o, objects)方法，而是methodProxy.invoke(o, objects)方法，为什么会引起死循环，导致内存溢出呢？由MethodProxy的源码可知，在MethodProxy的invoke方法中调用了被代理类的FastClass的invoke方法，所以，接下来看一下被代理类的FastClass(InfoDemo$$FastClassByCGLIB$$f4c7f3ac.class)被反编译后的部分源码。
public class InfoDemo$$FastClassByCGLIB$$f4c7f3ac extends FastClass {
public Object invoke(Object obj, Object[] args) throws Throwable {
try {
switch(var10001) {
case 0:
//调用被代理对象的被代理方法welcome
var10000.welcome((String)var3[0]);
return null;
case 1:
}
}
}
}
在被代理类的FastClass的invoke方法中调用被代理对象的welcome方法，通过代理对象调用被代理方法，与在main函数中instance.welcome(“zhangsan”)是一样的步骤，即又从头开始循环调用，直到栈内存溢出。
