jdk动态代理和cglib动态代理的原理分析

「爱情、让人受尽委屈。」 2023-03-14 10:38 7阅读 0赞

### 文章目录 ###

*  一、基本代理知识了解
 *   *  ①静态代理
     *  ②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?

# 一、基本代理知识了解 #

![在这里插入图片描述][20200517200436420.png]

## ①静态代理 ##

静态代理是设计模式中规范的模式。  
来个例子:  
定义个接口: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();
        }
    }

![在这里插入图片描述][20200517131151459.png]  
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();
           }
       }
    }

![在这里插入图片描述][20200517133404133.png]  
吧new Gril()换成 son

Person obj = (Person) new JDKMeipo().getInstance(new Son());
     obj.findLove();

![在这里插入图片描述][20200517133517978.png]  
可以看到只要给个对象，就能被动态代理对象处理。实现了静态代理做不到的需求。

## ③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();
            }
        }
    }

![在这里插入图片描述][20200517134216515.png]  
代理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();
            }
        }
    }

![在这里插入图片描述][20200517134356740.png]

> 可以看到，媒婆对象没做任何改变，只要给他个被代理对象，就能动态实现代理。也实现了上面静态代理实现不了的那2个需求。

`自此，动态代理2种方式的使用demo就完成了，继续深入思考的问题:`

--------------------

# 二.jdk动态代理和cglib动态代理的共同点? #

相对于静态代理，

*  表面上: 动态代理就是刚才完成了刚才那个2个需求，帮我们完成动态代理对象，不需要手写代理类的方法，可以切换不同的代理对象。
 *  本质上: jdk和cglib 在运行时动态生成代码，把代理对象的方法都给生成了一遍，形成了一个新的代理类。

那jdk和cglob生成的代理类的代码是什么样的呢?怎么生成的呢?

# 三.jdk动态代理是怎么生成代理对象的? #

我们看下媒婆类:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70]  
这行代码的作用就是生成一个代理对象:  
进入这个代码的源码:  
这段代码是生成代理类的逻辑:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 1]  
看到: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();
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 2]  
看下这个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方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 3]

这样我们客户端调用:

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的话，准备办事");
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 4]

这里面的代码不跟了，有点复杂，说下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();
            }
    
        }
    }

![在这里插入图片描述][20200517145415637.png]  
![在这里插入图片描述][20200517145504519.png]  
箭头指的是代理类，其他2个是FastClass类，一个是代理类的FastClass，一个是被代理类的FastClass机制。  
FastClass机制就是对一个类的方法建立索引，调用方法时根据方法的签名来计算索引，通过索引来直接调用相应的方法。  
看下代理类的class:  
参考:[https://blog.csdn.net/P19777/article/details/103998918][https_blog.csdn.net_P19777_article_details_103998918]

//
    // 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,为了以后调用被代理类的方法  
    ![在这里插入图片描述][20200517151229714.png]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 5]  
    每一个方法，比如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方法:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 6]

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");
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 7]  
最终调到了 ，被代理类的findLove()方法。  
cglib这里有点复杂，重新梳理下:

> CglibTest

![在这里插入图片描述][20200517154334221.png]

进入到代理类中调用findLove（）方法:

> `Customer$$EnhancerByCGLIB$$558ee7c6`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 8]  
调用的时候会，如果媒婆类CGlibMeipo，写了拦截方法，所以会跳到intercept()

> CGlibMeipo

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 9]

执行完before，开始调动methodProxy的invokeSuper方法，

> MethodProxy  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 10]  
> //f1;`com.example.proxy.staticproxy.Son`  
> //f2.`com.example.proxy.staticproxy.Son$$EnhancerByCGLIB$$d760ccc`

继续走代理类的代理类的fastClass`com.example.proxy.staticproxy.Son$$EnhancerByCGLIB$$d760ccc`的invoke方法:

> `com.example.proxy.staticproxy.Son$$EnhancerByCGLIB$$d760ccc`

![在这里插入图片描述][20200517171353242.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 11]  
到了这里又返回到了代理类`Son$$EnhancerByCGLIB$$d760ccc`中,开始执行 `CGLIB$findLove$0(）`方法:

> 代理类: `Son$$EnhancerByCGLIB$$d760ccc`

![在这里插入图片描述][20200517171459783.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 12]

该类继承了Son，所以走Son里面的finidLove方法:

> `Son`

![在这里插入图片描述][20200517171652633.png]

执行完返回到媒婆动态代理类的after()方法:

> `CGlibMeipo`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 13]

到此就执行完了，返回到了测试类中:  
`CglibTest`  
![在这里插入图片描述][20200517171902811.png]  
![在这里插入图片描述][2020051717193556.png]

自此，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。

--------------------

这篇文章只是动态代理的代码跟踪，看了2篇博客写的挺好的，也推荐下:

Enhancer [https://blog.csdn.net/gyshun/article/details/81000997][https_blog.csdn.net_gyshun_article_details_81000997]

CGLib FastClass [https://www.jianshu.com/p/0604d79435f1][https_www.jianshu.com_p_0604d79435f1]

文章中演示代码地址: [https://github.com/hufanglei/pattern-learn/tree/master/src/main/java/com/example/proxy][https_github.com_hufanglei_pattern-learn_tree_master_src_main_java_com_example_proxy]

--------------------

个人微信公众号：  
搜索： 怒放de每一天  
不定时推送相关文章，期待和大家一起成长！！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 14]

--------------------

完

[20200517200436420.png]: /images/20230312/3b67d4587c1e4020a0e61afcfdb9fd4a.png
[20200517131151459.png]: /images/20230312/3b507726203145f49d4cd6d17900160c.png
[20200517133404133.png]: /images/20230312/b8c102986ff94370b7e7002c79531aa1.png
[20200517133517978.png]: /images/20230312/91d45cccd40046da9e8c701bb81f8d20.png
[20200517134216515.png]: /images/20230312/89df238bd8e04288b5dbc239242a3ba7.png
[20200517134356740.png]: /images/20230312/99a262bd13684c1b94b098ac572b25f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70]: /images/20230312/82f249d10bc846e2a50dafc288190bd0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 1]: /images/20230312/24dde8bd36c349eb84098144dcd855a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 2]: /images/20230312/0c58c9a105964625a2b17f3b7b9949cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 3]: /images/20230312/6306886822c94757b1ef15812f41414b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 4]: /images/20230312/476ebe67b5004f60ab9f00f566ad04fa.png
[20200517145415637.png]: /images/20230312/ae165e339e7042ec8197a939b91fbf9a.png
[20200517145504519.png]: /images/20230312/00ef3372c50d4dda95d8867b20411490.png
[https_blog.csdn.net_P19777_article_details_103998918]: https://blog.csdn.net/P19777/article/details/103998918
[20200517151229714.png]: /images/20230312/cebbcba8febe45eb804ae6451e35e37e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 5]: /images/20230312/030aa1e3f5354159b583406f0e2da607.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 6]: /images/20230312/c54d31f83997414eb7b7de37a324b882.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 7]: /images/20230312/d721e51e899941fd99384de723824c59.png
[20200517154334221.png]: /images/20230312/5f4d42c728be4d86a64613073159362a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 8]: /images/20230312/6302ff41c6484021914fbcc7860a14aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 9]: /images/20230312/fb607e5c56494088b0aa4b23e68ce872.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 10]: /images/20230312/bc195bed820c4660b8e7e8e237094f15.png
[20200517171353242.png]: /images/20230312/4360253c9df244049e9f34c47ae00cea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 11]: /images/20230312/a3b4b3f7c80d45e9a1dcd0d3db6ffdf8.png
[20200517171459783.png]: /images/20230312/4898be46691346a48df13f827b02ff07.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 12]: /images/20230312/d87d7cbd3e1a41869ba5c86e268635ed.png
[20200517171652633.png]: /images/20230312/56644b6a2caa46a2bb6f79d9fabaea32.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 13]: /images/20230312/82ac758f795a40a59883d72475f4272d.png
[20200517171902811.png]: /images/20230312/4106dbdd487e4446b1fbf346d41a840c.png
[2020051717193556.png]: /images/20230312/8f532ea93f334d30aff99a5ab4f391e6.png
[https_blog.csdn.net_gyshun_article_details_81000997]: https://blog.csdn.net/gyshun/article/details/81000997
[https_www.jianshu.com_p_0604d79435f1]: https://www.jianshu.com/p/0604d79435f1
[https_github.com_hufanglei_pattern-learn_tree_master_src_main_java_com_example_proxy]: https://github.com/hufanglei/pattern-learn/tree/master/src/main/java/com/example/proxy
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhaWR1XzIxMzQ5NjM1_size_16_color_FFFFFF_t_70 14]: /images/20230312/eb613084da62400e88d08c50de478bd3.png