文章目录
- 一、基本代理知识了解
- ①静态代理
- ②jdk动态代理
- ③cglib动态代理
- 二.jdk动态代理和cglib动态代理的共同点?
- 三.jdk动态代理是怎么生成代理对象的?
- 四.cglib是怎么生成代理对象的?
- 五.jdk和cglib各自怎么调用被代理对象的方法?
- 六.cglib动态生成的代理对象的时候为什么是3个class?
本文解决一下几个问题：
- 1.jdk动态代理和cglib动态代理的共同点？
- 2.jdk动态代理是怎么生成代理对象的?
- 3.cglib是怎么生成代理对象的?
- 4.jdk和cglib各自怎么调用被代理对象的方法?
- 5.cglib动态生成的代理对象的时候为什么是3个class?
一、基本代理知识了解
①静态代理
静态代理是设计模式中规范的模式。
来个例子:
定义个接口:Person
public interface Person {
void findLove();
}
定义个被代理对象:Son
public class Son implements Person {
@Override
public void findLove() {
System.out.println("儿子要求：肤白貌美大长腿");
}
}
定义个代理对象:，自己不实现方法，用被代理对象的方法操作。
public class Father implements Person {
private Son person;
public Father(Son person) {
this.person = person;
}
@Override
public void findLove() {
System.out.println("父亲物色对象");
this.person.findLove();
System.out.println("双方父母同意，确立关系");
}
}
测试
public class FatherProxyTest {
public static void main(String[] args) {
final Father father = new Father(new Son());
father.findLove();
}
}
ok，静态代理的demo完毕。
提个需求:如果被代理对象son还有个方法marry()想被客户端调用，那代理对象father就得手动加个方法marry()与之对应。才能让客户端只调用father代理对象就可以。
有100个方法呢，father得累死。这好像与设计模式的开闭原则有点不一致。
再提个需求:要求不仅可以代理儿子的方法，可能还有女儿的方法，张三，李四的方法？，那我还得在father对象不断添加被代理对象的属性吗？
能不能有个万能的媒婆，儿子如果有其他的方法，father能动态添加，而且其他不同的被代理对象(女儿，张三，李四)?
可以的，这就是java动态代理。
动态代理本质也是生成被代理对象的多个方法与之对应，只不过我们这些码农不需要手动写，而是借用java的一些机制帮我们实现。
java提供了2种动态代理，一种是jdk动态代理，一种是cglib动态代理。
先完成这2个的demo:
②jdk动态代理
这里father对象就不用了，换个媒婆,作为万能动态代理对象:
public class JDKMeipo implements InvocationHandler {
//被代理的对象，把引用给保存下来
private Object target;
public Object getInstance(Object target) throws Exception {
this.target = target;
Class<?> clazz = target.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object obj = method.invoke(this.target, args);
after();
return obj;
}
private void before() {
System.out.println("我是媒婆：我要给你找对象，现在已经拿到你的需求");
System.out.println("开始物色");
}
private void after() {
System.out.println("如果合适的话，就准备办事");
}
}
再来个被代理对象Gril
public class Girl implements Person {
@Override
public void findLove() {
System.out.println("高富帅");
System.out.println("身高180cm");
System.out.println("有6块腹肌");
}
}
测试：
public class JDKProxyTest {
public static void main(String[] args) {
try {
Person obj = (Person) new JDKMeipo().getInstance(new Girl());
obj.findLove();
}catch (Exception e){
e.printStackTrace();
}
}
}
吧new Gril()换成 son
Person obj = (Person) new JDKMeipo().getInstance(new Son());
obj.findLove();
可以看到只要给个对象，就能被动态代理对象处理。实现了静态代理做不到的需求。
③cglib动态代理
再来个cglib的demo:
CGlibMeipo媒婆:
public class CGlibMeipo implements MethodInterceptor {
public Object getInstance(Class<?> clazz) throws Exception{
//相当于Proxy，代理的工具类
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 obj = methodProxy.invokeSuper(o,objects);
after();
return obj;
}
private void before(){
System.out.println("我是媒婆，我要给你找对象，现在已经确认你的需求");
System.out.println("开始物色");
}
private void after(){
System.out.println("OK的话，准备办事");
}
}
还是用刚才的girl和son测试:
public class CglibTest {
public static void main(String[] args) {
try {
Girl instance = (Girl) new CGlibMeipo().getInstance(Girl.class);
instance.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
}
代理son对象:
public class CglibTest {
public static void main(String[] args) {
try {
Son instance = (Son) new CGlibMeipo().getInstance(Son.class);
instance.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
}
可以看到，媒婆对象没做任何改变，只要给他个被代理对象，就能动态实现代理。也实现了上面静态代理实现不了的那2个需求。
自此，动态代理2种方式的使用demo就完成了，继续深入思考的问题:
二.jdk动态代理和cglib动态代理的共同点?
相对于静态代理，
- 表面上: 动态代理就是刚才完成了刚才那个2个需求，帮我们完成动态代理对象，不需要手写代理类的方法，可以切换不同的代理对象。
- 本质上: jdk和cglib 在运行时动态生成代码，把代理对象的方法都给生成了一遍，形成了一个新的代理类。
那jdk和cglob生成的代理类的代码是什么样的呢?怎么生成的呢?
三.jdk动态代理是怎么生成代理对象的?
我们看下媒婆类:
这行代码的作用就是生成一个代理对象:
进入这个代码的源码:
这段代码是生成代理类的逻辑:
看到:1的作用:
1、拿到被代理对象的引用，并且获取到它的所有的接口，反射获取。
2、JDK Proxy 类重新生成一个新的类
看到:2的作用:
将媒婆这个处理逻辑的类，当成新的代理类的一个参数，并被构造方法调用。然后动态生成代理类代码。
生成的代理类是什么样的？怎么看呢? 在媒婆的同级目录下，写个测试类，用流出来:
public class JDKProxyTest {
public static void main(String[] args) {
try {
//通过反编译工具可以查看源代码
byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{Person.class});
FileOutputStream os = new FileOutputStream("E://$Proxy0.class");
os.write(bytes);
os.close();
}catch (Exception e){
e.printStackTrace();
}
}
}
看下这个class的源码
public final class $Proxy0 extends Proxy implements Person {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void findLove() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m3 = Class.forName("com.example.proxy.Person").getMethod("findLove");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
这个类是动态生成的代理类。可以看到m3：是通过反射动态生成的findLove方法。
我们调用这个 $Proxy0代理类的findLove
public final void findLove() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
会执行我们写的JDKMeipo的invoke方法
这样我们客户端调用:
Object obj = new JDKMeipo().getInstance(new Girl());
这行代码的时候,其实是调用的 $Proxy0代理类,findLove方法，把JDKMeipo的before(),新生成的m3(对应原始被代理的findLove)，after()方法执行了。
这里注意:
Object obj = method.invoke(this.target, args); 就是最终调用被代理类的逻辑。用的反射机制调用，其实效率不如cglib，为什么，继续研究:
四.cglib是怎么生成代理对象的?
既然jdk动态代理采用反射调用效率不高，那cglib怎么做到的呢?
看下CGlibMeipo媒婆类:
public class CGlibMeipo implements MethodInterceptor {
public Object getInstance(Class<?> clazz) throws Exception{
//相当于Proxy，代理的工具类
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 obj = methodProxy.invokeSuper(o,objects);
after();
return obj;
}
private void before(){
System.out.println("我是媒婆，我要给你找对象，现在已经确认你的需求");
System.out.println("开始物色");
}
private void after(){
System.out.println("OK的话，准备办事");
}
}
这里面的代码不跟了，有点复杂，说下create()最后的结果，是生产了3个class。我们想办法获取他们的源码:
public class CglibTest1 {
public static void main(String[] args) {
try {
//JDK是采用读取接口的信息
//CGLib覆盖父类方法
//目的：都是生成一个新的类，去实现增强代码逻辑的功能
//JDK Proxy 对于用户而言，必须要有一个接口实现，目标类相对来说复杂
//CGLib 可以代理任意一个普通的类，没有任何要求
//CGLib 生成代理逻辑更复杂，效率,调用效率更高，生成一个包含了所有的逻辑的FastClass，不再需要反射调用
//JDK Proxy生成代理的逻辑简单，执行效率相对要低，每次都要反射动态调用
//CGLib 有个坑，CGLib不能代理final的方法
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"E://cglib_proxy_classes");
Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
System.out.println(obj);
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
}
箭头指的是代理类，其他2个是FastClass类，一个是代理类的FastClass，一个是被代理类的FastClass机制。
FastClass机制就是对一个类的方法建立索引，调用方法时根据方法的签名来计算索引，通过索引来直接调用相应的方法。
看下代理类的class:
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.example.proxy.dynamicproxy.cglibproxy;
import java.lang.reflect.Method;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Factory;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
public class Customer$$EnhancerByCGLIB$$558ee7c6 extends Customer implements Factory {
private boolean CGLIB$BOUND;
public static Object CGLIB$FACTORY_DATA;
private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
private static final Callback[] CGLIB$STATIC_CALLBACKS;
private MethodInterceptor CGLIB$CALLBACK_0;
private static Object CGLIB$CALLBACK_FILTER;
private static final Method CGLIB$findLove$0$Method;
private static final MethodProxy CGLIB$findLove$0$Proxy;
private static final Object[] CGLIB$emptyArgs;
private static final Method CGLIB$equals$1$Method;
private static final MethodProxy CGLIB$equals$1$Proxy;
private static final Method CGLIB$toString$2$Method;
private static final MethodProxy CGLIB$toString$2$Proxy;
private static final Method CGLIB$hashCode$3$Method;
private static final MethodProxy CGLIB$hashCode$3$Proxy;
private static final Method CGLIB$clone$4$Method;
private static final MethodProxy CGLIB$clone$4$Proxy;
static void CGLIB$STATICHOOK1() {
CGLIB$THREAD_CALLBACKS = new ThreadLocal();
CGLIB$emptyArgs = new Object[0];
Class var0 = Class.forName("com.example.proxy.dynamicproxy.cglibproxy.Customer$$EnhancerByCGLIB$$558ee7c6");
Class var1;
CGLIB$findLove$0$Method = ReflectUtils.findMethods(new String[]{"findLove", "()V"}, (var1 = Class.forName("com.example.proxy.dynamicproxy.cglibproxy.Customer")).getDeclaredMethods())[0];
CGLIB$findLove$0$Proxy = MethodProxy.create(var1, var0, "()V", "findLove", "CGLIB$findLove$0");
Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
CGLIB$equals$1$Method = var10000[0];
CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
CGLIB$toString$2$Method = var10000[1];
CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
CGLIB$hashCode$3$Method = var10000[2];
CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
CGLIB$clone$4$Method = var10000[3];
CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
}
final void CGLIB$findLove$0() {
super.findLove();
}
public final void findLove() {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
if (var10000 != null) {
var10000.intercept(this, CGLIB$findLove$0$Method, CGLIB$emptyArgs, CGLIB$findLove$0$Proxy);
} else {
super.findLove();
}
}
final boolean CGLIB$equals$1(Object var1) {
return super.equals(var1);
}
public final boolean equals(Object var1) {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
if (var10000 != null) {
Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy);
return var2 == null ? false : (Boolean)var2;
} else {
return super.equals(var1);
}
}
final String CGLIB$toString$2() {
return super.toString();
}
public final String toString() {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString();
}
final int CGLIB$hashCode$3() {
return super.hashCode();
}
public final int hashCode() {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
if (var10000 != null) {
Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
return var1 == null ? 0 : ((Number)var1).intValue();
} else {
return super.hashCode();
}
}
final Object CGLIB$clone$4() throws CloneNotSupportedException {
return super.clone();
}
protected final Object clone() throws CloneNotSupportedException {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone();
}
public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
String var10000 = var0.toString();
switch(var10000.hashCode()) {
case -508378822:
if (var10000.equals("clone()Ljava/lang/Object;")) {
return CGLIB$clone$4$Proxy;
}
break;
case 1192015562:
if (var10000.equals("findLove()V")) {
return CGLIB$findLove$0$Proxy;
}
break;
case 1826985398:
if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
return CGLIB$equals$1$Proxy;
}
break;
case 1913648695:
if (var10000.equals("toString()Ljava/lang/String;")) {
return CGLIB$toString$2$Proxy;
}
break;
case 1984935277:
if (var10000.equals("hashCode()I")) {
return CGLIB$hashCode$3$Proxy;
}
}
return null;
}
public Customer$$EnhancerByCGLIB$$558ee7c6() {
CGLIB$BIND_CALLBACKS(this);
}
public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
CGLIB$THREAD_CALLBACKS.set(var0);
}
public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
CGLIB$STATIC_CALLBACKS = var0;
}
private static final void CGLIB$BIND_CALLBACKS(Object var0) {
Customer$$EnhancerByCGLIB$$558ee7c6 var1 = (Customer$$EnhancerByCGLIB$$558ee7c6)var0;
if (!var1.CGLIB$BOUND) {
var1.CGLIB$BOUND = true;
Object var10000 = CGLIB$THREAD_CALLBACKS.get();
if (var10000 == null) {
var10000 = CGLIB$STATIC_CALLBACKS;
if (var10000 == null) {
return;
}
}
var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
}
}
public Object newInstance(Callback[] var1) {
CGLIB$SET_THREAD_CALLBACKS(var1);
Customer$$EnhancerByCGLIB$$558ee7c6 var10000 = new Customer$$EnhancerByCGLIB$$558ee7c6();
CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
return var10000;
}
public Object newInstance(Callback var1) {
CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
Customer$$EnhancerByCGLIB$$558ee7c6 var10000 = new Customer$$EnhancerByCGLIB$$558ee7c6();
CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
return var10000;
}
public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
CGLIB$SET_THREAD_CALLBACKS(var3);
Customer$$EnhancerByCGLIB$$558ee7c6 var10000 = new Customer$$EnhancerByCGLIB$$558ee7c6;
switch(var1.length) {
case 0:
var10000.<init>();
CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
return var10000;
default:
throw new IllegalArgumentException("Constructor not found");
}
}
public Callback getCallback(int var1) {
CGLIB$BIND_CALLBACKS(this);
MethodInterceptor var10000;
switch(var1) {
case 0:
var10000 = this.CGLIB$CALLBACK_0;
break;
default:
var10000 = null;
}
return var10000;
}
public void setCallback(int var1, Callback var2) {
switch(var1) {
case 0:
this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
default:
}
}
public Callback[] getCallbacks() {
CGLIB$BIND_CALLBACKS(this);
return new Callback[]{this.CGLIB$CALLBACK_0};
}
public void setCallbacks(Callback[] var1) {
this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
}
static {
CGLIB$STATICHOOK1();
}
}
解释下:
这个类做了一下工作:
- 1.继承 了被代理类的对象。
第一行extends Customer - 2.生成了被代理对象的所有父方法，并用
CGLIB$开头表示：
final void CGLIB$findLove$0() {
super.findLove();
}
/**
* 用来调用父类的原始方法
* CGLIB生成代理利用的是继承，而不是JDK动态代理的利用接口的形式
* 这样就有一个区别就出现了，JDK动态代理中必须要有一个被代理类的实例
* 但是CGLIB实现的动态代理就不需要，因为是继承，所以就包含了被代理类的全部方法
* 但是我们调用生成的代理类实例的toString()方法时，调用的就是CGLIB代理时候的方法
* 如果调用被代理类的原始方法呢，就是靠下面的这个方法
* CGLIB生成的代理类中每个原始方法都会有这两种类型的方法
*/
- 3.重写了代理对象的方法,
比如:
public final void findLove() {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
if (var10000 != null) {
var10000.intercept(this, CGLIB$findLove$0$Method, CGLIB$emptyArgs, CGLIB$findLove$0$Proxy);
} else {
super.findLove();
}
/**
* 生成的代理方法，在该方法中会调用我们设置的Callback
* 当调用代理类的findLove方法时，先判断是否已经存在实现了MethodInterceptor接口的拦截对象
* 如果没有的话就调用CGLIB$BIND_CALLBACKS方法来获取Callback
*/
- 4.生成MethodProxy,为了以后调用被代理类的方法
- 每一个方法，比如findLove方法，都会有一个MethodProxy.
CGLIB$STATICHOOK1()这个静态方法内执行了MethodProxy.create()方法，为所有的都生成了对应的MethodProxy，MethodProxy就会当参数被传递到MethodInterceptor.intercept()方法中，代表了一个方法的FastClass机制.
/**
* c1是Object.class
* c2是代理类的class
* name1是被代理类中的原始方法名
* name2是代理类中新增的代理方法的方法名
*/
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;
}
在intercept()方法中执行MethodProxy的invokeSuper方法:
public Object invokeSuper(Object obj, Object[] args) throws Throwable {
try {
// 调用init方法，获取下标，且要生成FastClass类实例
init();
FastClassInfo fci = fastClassInfo;
// f2是被代理类的FastClass实例，下标在init方法中计算好了
// 假设我们调用的上面的toString()方法，其实也就是调用的代理类的CGLIB$toString$0方法，这样就实现了原始方法的调用，所以我们才需要执行invokeSuper，如果调用invoke，就会形成死循环
return fci.f2.invoke(fci.i2, obj, args);
} catch (InvocationTargetException e) {
throw e.getTargetException();
}
}
/**
* invoke执行的是原始类的方法，因为f1是被代理类的FastClass
*
*/
public Object invoke(Object obj, Object[] args) throws Throwable {
try {
init();
FastClassInfo fci = fastClassInfo;
return fci.f1.invoke(fci.i1, obj, args);
} catch (InvocationTargetException e) {
throw e.getTargetException();
} catch (IllegalArgumentException e) {
if (fastClassInfo.i1 < 0)
throw new IllegalArgumentException("Protected method: " + sig1);
throw e;
}
}
看下被代理类的fastClass的invoke方法()：
public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
558ee7c6 var10000 = (558ee7c6)var2;
int var10001 = var1;
try {
switch(var10001) {
case 0:
return new Boolean(var10000.equals(var3[0]));
case 1:
return var10000.toString();
case 2:
return new Integer(var10000.hashCode());
case 3:
return var10000.clone();
case 4:
return var10000.newInstance((Callback[])var3[0]);
case 5:
return var10000.newInstance((Class[])var3[0], (Object[])var3[1], (Callback[])var3[2]);
case 6:
return var10000.newInstance((Callback)var3[0]);
case 7:
var10000.setCallbacks((Callback[])var3[0]);
return null;
case 8:
var10000.findLove();
return null;
case 9:
var10000.setCallback(((Number)var3[0]).intValue(), (Callback)var3[1]);
return null;
case 10:
return var10000.getCallback(((Number)var3[0]).intValue());
case 11:
return var10000.getCallbacks();
case 12:
558ee7c6.CGLIB$SET_STATIC_CALLBACKS((Callback[])var3[0]);
return null;
case 13:
558ee7c6.CGLIB$SET_THREAD_CALLBACKS((Callback[])var3[0]);
return null;
case 14:
return 558ee7c6.CGLIB$findMethodProxy((Signature)var3[0]);
case 15:
return new Boolean(var10000.CGLIB$equals$1(var3[0]));
case 16:
return var10000.CGLIB$toString$2();
case 17:
var10000.CGLIB$findLove$0();
return null;
case 18:
return var10000.CGLIB$clone$4();
case 19:
return new Integer(var10000.CGLIB$hashCode$3());
case 20:
558ee7c6.CGLIB$STATICHOOK1();
return null;
}
} catch (Throwable var4) {
throw new InvocationTargetException(var4);
}
throw new IllegalArgumentException("Cannot find matching method/constructor");
}
最终调到了 ，被代理类的findLove()方法。
cglib这里有点复杂，重新梳理下:
CglibTest
进入到代理类中调用findLove（）方法:
Customer$$EnhancerByCGLIB$$558ee7c6
调用的时候会，如果媒婆类CGlibMeipo，写了拦截方法，所以会跳到intercept()
CGlibMeipo
执行完before，开始调动methodProxy的invokeSuper方法，
MethodProxy
//f1;
com.example.proxy.staticproxy.Son
//f2.
com.example.proxy.staticproxy.Son$$EnhancerByCGLIB$$d760ccc
继续走代理类的代理类的fastClasscom.example.proxy.staticproxy.Son$$EnhancerByCGLIB$$d760ccc的invoke方法:
com.example.proxy.staticproxy.Son$$EnhancerByCGLIB$$d760ccc
到了这里又返回到了代理类Son$$EnhancerByCGLIB$$d760ccc中,开始执行 CGLIB$findLove$0(）方法:
代理类: Son$$EnhancerByCGLIB$$d760ccc
该类继承了Son，所以走Son里面的finidLove方法:
Son
执行完返回到媒婆动态代理类的after()方法:
CGlibMeipo
到此就执行完了，返回到了测试类中:
CglibTest
自此，cglib动态创建代理对象就调试完了。
下面开始总结下:
五.jdk和cglib各自怎么调用被代理对象的方法?
1.JDK 动态代理是实现了被代理对象的接口，CGLib 是继承了被代理对象。
2.JDK 和CGLib 都是在运行期生成字节码，JDK 是直接写Class 字节码，CGLib 使用ASM
框架写Class 字节码，Cglib 代理实现更复杂，生成代理类比JDK 效率低。
3.JDK 调用代理方法，是通过反射机制调用，CGLib 是通过FastClass 机制直接调用方法，
CGLib 执行效率更高。
六.cglib动态生成的代理对象的时候为什么是3个class?
首先cglib需要创建一个代理对象，这是必然的，多出来的2个class文件，是因为cglib没有使用反射，而是使用fastclass维护每个方法的索引。一个类保存代理对象的方法索引，一个保存被代理对象的索引。这样当客户端调用的时候，fastclass机制就提供给客户端相应的方法区执行。所以是3个class。
个人微信公众号：
搜索： 怒放de每一天
不定时推送相关文章，期待和大家一起成长！！
完