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

简介: jdk动态代理和cglib动态代理的原理分析(上)

本文解决一下几个问题:


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


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


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


4.jdk和cglib各自怎么调用被代理对象的方法?


5.cglib动态生成的代理对象的时候为什么是3个class?


一、基本代理知识了解


1dc618a0ed9580ce8bfa6facb208c08f.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();
    }
}


5d4c6812c8535adbb050f4ddf2e1bce8.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();
       }
   }
}

46a9d80a6e05e4e3b19d57a0ee70bcdf.png

吧new Gril()换成 son


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


1dc618a0ed9580ce8bfa6facb208c08f.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();
        }
    }
}


5d4c6812c8535adbb050f4ddf2e1bce8.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();
        }
    }
}


1dc618a0ed9580ce8bfa6facb208c08f.png


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


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


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


相对于静态代理,


表面上: 动态代理就是刚才完成了刚才那个2个需求,帮我们完成动态代理对象,不需要手写代理类的方法,可以切换不同的代理对象。


本质上: jdk和cglib 在运行时动态生成代码,把代理对象的方法都给生成了一遍,形成了一个新的代理类。


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


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


我们看下媒婆类:

1dc618a0ed9580ce8bfa6facb208c08f.png


这行代码的作用就是生成一个代理对象:


进入这个代码的源码:


这段代码是生成代理类的逻辑:

5d4c6812c8535adbb050f4ddf2e1bce8.png

看到: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();
        }
    }
}


1dc618a0ed9580ce8bfa6facb208c08f.png

看下这个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方法


1dc618a0ed9580ce8bfa6facb208c08f.png

这样我们客户端调用:


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


1dc618a0ed9580ce8bfa6facb208c08f.png

这里面的代码不跟了,有点复杂,说下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,为了以后调用被代理类的方法

1dc618a0ed9580ce8bfa6facb208c08f.png5d4c6812c8535adbb050f4ddf2e1bce8.png


每一个方法,比如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;
}
相关文章
|
2天前
|
Java Spring
深入解析Spring源码,揭示JDK动态代理的工作原理。
深入解析Spring源码,揭示JDK动态代理的工作原理。
8 0
|
1月前
|
缓存 自然语言处理 JavaScript
万字长文深度解析JDK序列化原理及Fury高度兼容的极致性能实现
Fury是一个基于JIT动态编译的高性能多语言原生序列化框架,支持Java/Python/Golang/C++/JavaScript等语言,提供全自动的对象多语言/跨语言序列化能力,以及相比于别的框架最高20~200倍的性能。
168550 6
|
1月前
|
设计模式 Java
JDK动态代理
JDK动态代理
|
1月前
|
Java 程序员 API
浅谈JDK动态代理
浅谈JDK动态代理
40 1
|
1月前
|
设计模式 Java API
[Java]静态代理、动态代理(基于JDK1.8)
本篇文章主要是对静态代理和动态代理实现思路的简述,以示例为主,少涉及理论。 如果文中阐述不全或不对的,多多交流。
62 1
[Java]静态代理、动态代理(基于JDK1.8)
|
1月前
|
Java
关于JDK动态代理
关于JDK动态代理的一些理解
18 0
|
1天前
|
Java 关系型数据库 MySQL
杨校老师课堂之Java项目部署到云端服务器之安装MySQL、Jdk、Tomcat
杨校老师课堂之Java项目部署到云端服务器之安装MySQL、Jdk、Tomcat
8 0
杨校老师课堂之Java项目部署到云端服务器之安装MySQL、Jdk、Tomcat
|
13天前
|
Oracle Java 关系型数据库
玩客云安装Armbian和部署jdk环境
该文介绍了在玩客云设备上安装Armbian系统和Java SDK的步骤。首先,需要准备玩客云设备、Armbian镜像文件和USB工具。然后,通过短接点刷入Armbian系统,并通过SSH访问。接着,从可信源下载Java SDK,将其解压并移动到合适目录,编辑环境变量使其生效。最后验证Java安装成功。注意选择兼容版本并备份数据。内容涵盖了ROM开发相关技术。
|
14天前
|
Oracle Java 关系型数据库
Java入门——开发环境、入门程序(搭建Java开发环境、安装JDK 验证、JDK、编写代码、编译代码、运行代码)
Java入门——开发环境、入门程序(搭建Java开发环境、安装JDK 验证、JDK、编写代码、编译代码、运行代码)
22 3
|
16天前
|
Java
树莓派安装java jdk8
树莓派安装java jdk8