本文解决一下几个问题：

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:

参考: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,为了以后调用被代理类的方法

每一个方法，比如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;
}

jdk动态代理和cglib动态代理的原理分析(上）

一、基本代理知识了解

①静态代理

②jdk动态代理

③cglib动态代理

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

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

四.cglib是怎么生成代理对象的?

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

jdk动态代理和cglib动态代理的原理分析(上）

一、基本代理知识了解

①静态代理

②jdk动态代理

③cglib动态代理

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

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

四.cglib是怎么生成代理对象的?

热门文章

最新文章

相关课程

相关电子书