【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)

简介

动态代理,通俗点说就是:无需声明式的创建java代理类,而是在运行过程中生成"虚拟"的代理类,被ClassLoader加载。 从而避免了静态代理那样需要声明大量的代理类。

上面的简介中提到了两个关键的名词:“静态代理”和“动态代理”

我们先来看来下两个问题:

  • 首先什么是代理呢?

它可以看作是对最终调用目标的一个封装,可以通过操作代理对象来调用目标类,这样就可以实现调用者和目标对象的解耦合

  • “静态代理”和“动态代理”又有什么区别呢?

这是代理模式的两种类型,Java中(JDK从1.3版本开始支持动态代理)主要是通过java.lang.reflect.Proxy和java.lang.reflect.InvocationHandler这两个类配合使用来实现的,而所谓的“静态”和“动态”其实也就是代理类的字节码文件创建的时间不同,“静态代理”是在程序运行前就知道了哪些对象需要创建代理对象,“动态代理”则是在程序运行中动态的判断哪些对象需要创建代理对象

Java中主要有两种"动态代理"的实现方式:JDK和CGLIB

他们最主要的区别简单来讲就是

  1. JDK动态代理针对实现了接口的类生成代理(必须实现接口)

  1. CGLIB动态代理是针对实现代理(无需实现接口)

动态代理这个东西吧。。。个人的感觉是不自己走一遍流程,看别人讲再多遍,总是不踏实,本系列就是一套保姆级的Debug教程,接下来会通过两个示例,跟我一起手把手地捋下JDK动态代理和CGLIB动态代理创建代理对象的基本流程

JDK

这个案例我们一共需要创建4个文件

创建测试文件

IService:接口文件

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第1张图片
public interface IService {
   void A();

   String B(int i);
}

MyService:实现类(被代理类)

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第2张图片
public class MyService implements IService {
   @Override
   public void A() {
      System.out.println("This is A().");
   }

   @Override
   public String B(int i) {
      return "This is B()." + i;
   }
}

MyServiceProxy:代理创建类

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第3张图片
public class MyServiceProxy {
   public static IService getProxy(final IService iService) {
      /** 获取类加载器 */
      ClassLoader classLoader = iService.getClass().getClassLoader();
      /** 获取接口集合 */
      Class[] interfaces = iService.getClass().getInterfaces();
      InvocationHandler invocationHandler = new InvocationHandler() {
         @Override
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object invoke = method.invoke(iService, args);
            return invoke;
         }
      };
      Object proxyInstance = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
      return (IService) proxyInstance;
   }
}

Test:测试启动类

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第4张图片
public class Test {
   public static void main(String[] args) {
      System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
      IService proxy = MyServiceProxy.getProxy(new MyService());
      System.out.println(proxy.getClass());
      String b = proxy.B(1);
      System.out.println(b);
   }
}

Debug启动

在下图箭头指向位置处打上断点,然后Debug启动

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第5张图片

点击step into,来到需要创建代理的接口类中

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第6张图片

点击step into,进入类MyServiceProxy

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第7张图片

这个类中先获取类加载器,再获取接口们的集合,最后获取到handler后,3个参数一起传入newProxyInstance()方法中,用来创建我们的代理类

newProxyInstance()

我们进入newProxyInstance()方法中

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第8张图片

看下方法说明

Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler.

简单翻一下:返回一个指定接口的代理类的实例,该代理类将方法调用分派给指定的调用处理程序。

一开始先判断传入的InvocationHandler是否为空,接着获取接口、获取安全管理器

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第9张图片

然后是非常重要的一步:生成字节码文件

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第10张图片
getProxyClass0()

getProxyClass0()这个函数很复杂,我们进来瞅瞅(。・ω・。)ノ

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第11张图片

第一步,先判断了下接口个数,对需要代理的对象实现的接口数量做了一个限制(不能超过65535个)

第二步,通过proxyClassCache的get()方法获取代理类并返回(通过缓冲区查询数值)

这里有两种情况:

  1. 如果实现给定接口的给定加载器定义的代理类存在,这将简单地返回缓存的副本

  1. 否则,它将通过ProxyClassFactory创建代理类

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第12张图片

点击进入会执行到WeakCache中的get()方法(上图中可以看到proxyClassCache这个变量实际就是一个WeakCache对象)

get()
【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第13张图片

进入get()方法先判断传入的参数是否为空,然后移执行expungeStaleEntries()移除之前的内容

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第14张图片

尝试从map中获取key值,并经获取到的key值们转换成ConcurrentMap<Object, Supplier<V>>的类型

首先我们看下这个map是何方神圣

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第15张图片

这是一个map里面套着一个map,而且key的类型使用Object以便存储key值为null的对象

既然是尝试获取,就会出现两种情况:

  1. 获取到key

  1. 未获取到key

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第16张图片

如果未获取到会多执行一步putIfAbsent()方法(其余基本一致)

putIfAbsent()

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第17张图片

在这个方法中,如果指定的键还没有与一个值相关联(或被映射为null),则将其与给定的值相关联并返回null,否则就会返回当前值(其实就是如果获取到的valuesMap为null,就把key为null,value为valuesMap的对象放入map中,如果oldValuesMap获取到值了,就会给valuesMap赋个值,但是目前并没有获取到相关联的值(如下图,执行完putIfAbsent()方法后,map的值增加了一个,但是valuesMap仍为空))

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第18张图片

点击step over继续执行下面的逻辑

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第19张图片

出现了一个叫做"subKeyFactory"的变量,点击下进入到定义该变量的位置(就在这个类一开始)

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第20张图片

这是一个BiFunction<K, P, ?>类型的变量,BiFunction这是一个函数式接口,代表叻一个接受两个参数并产生一个结果的函数(apply())

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第21张图片

subKeyFactory在WeakCache对象初始化的时候进行了赋值

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第22张图片
this.subKeyFactory = Objects.requireNonNull(subKeyFactory);

所以subKeyFactory是有值的,调用叻他的apply()方法

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第23张图片

由于我们的接口只有一个所以会返回return new Key1(interfaces[0])

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第24张图片

此时已经获取到了接口对象,并从valuesMap中检索该子键所存储的可能的Supplier,由于valuesMap是空,所以valuesMap.get(subKey)并未获取到值

接着创建一个Factory对象并赋值为null

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第25张图片

由于从valuesMap.get(subKey)并未获取到值,所以不会进入supplier != null的判断逻辑代码块,直接进入下面创建一个Factory对象

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第26张图片

这个Factory对象实现了Supplier,实现了值的懒同步构建并将其放置到了缓存中

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第27张图片

把刚新建好的Factory赋值给变量supplier

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第28张图片

由于while(true)是个死循环,因此会再次进入循环中,此时由于刚刚的赋值,变量supplier已经不是null叻,于是会调用supplier的get()方法

get()

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第29张图片
【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第30张图片

apply()

在这个方法中,会生成我们代理对象的字节码文件

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第31张图片

generateProxyClass()方法执行完成后,其实就生成了我们当前代理对象的字节码文件(apply()方法详解可以参考代理对象的字节码文件生成详解 )

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第32张图片

方法执行完成后,返回到get()方法

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第33张图片

再返回到上一层的get()方法

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第34张图片

此时value也拿到叻值,接着通过return value跳出当前循环♻️

执行完getProxyClass0()方法,回到newProxyInstance()

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第35张图片

此时我们已经生成了代理类的字节码文件,也获取到了代理类,并赋值给了变量cl

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第36张图片

由于sm为null,跳过checkNewProxyPermission(),直接开始获取构造器,验证访问修饰符

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第37张图片

通过调用获取到的构造器的newInstance()方法获取实例对象并返回

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第38张图片

可以看到此时获取到的对象是com.aqin.custom.proxy.jdk.MyService@6d86b085

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第39张图片

返回到getProxy()

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第40张图片

获取到了代理对象,继续把测试启动类执行完

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第41张图片

JDK介绍完啦,我们开始CGLIB

CGLIB

创建测试文件

MyService:被代理类

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第42张图片

public class MyServic{
   public void A() {
      System.out.println("This is A().");
   }

   public String B(int i) {
      return "This is B()." + i;
   }
}

MyCglib:拦截器

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第43张图片
package com.aqin.custom.proxy.cglib;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @Description
 * @Author aqin1012 AQin.
 * @Date 12/28/22 5:36 PM
 * @Version 1.0
 */
public class MyCglib implements MethodInterceptor {
   @Override
   public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
      Object o1 = methodProxy.invokeSuper(o, objects);
      return o1;
   }
}

需要注意的是:MethodInterceptor和MethodProxy都要选org.springframework.cglib.proxy包下的

Test:测试启动类

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第44张图片
package com.aqin.custom.proxy.cglib;

import org.springframework.cglib.core.DebuggingClassWriter;
import org.springframework.cglib.proxy.Enhancer;

/**
 * @Description
 * @Author aqin1012 AQin.
 * @Date 12/28/22 5:29 PM
 * @Version 1.0
 */
public class Test {
   public static void main(String[] args) {
      /** 动态代理创建的字节码文件存储到本地 */
      System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "cglib_proxy");
      /** 通过cg11b动态代理获取代理对象的过程,创建调用的对象 */
      Enhancer enhancer = new Enhancer();
      /** 设置enhancer对象的父类 */
      enhancer.setSuperclass(MyService.class);
      /** 设置enhancer的回调对象 */
      enhancer.setCallback(new MyCglib());
      /** 创建代理对象 */
      MyService myService = (MyService) enhancer.create();
      /** 通过代理对象调用目标方法 */
      System.out.println(myService.B(999));
      System.out.println(myService.getClass());
   }
}

Debug启动

按照下图,在箭头指向的位置打上一个断点

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第45张图片

Debug的方式启动

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第46张图片

step into进入,会跳转到下图的位置

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第47张图片

继续向下执行,就会进入到Enhancer类中,这个类是生成动态子类以实现方法拦截的(JDK 1.3中引入),它并不需要被代理类一定实现了某个接口(这是与JDK动态代理的主要区别),动态生成的子类会覆盖超类的非最终方法,并回调到用户定义的拦截器实现的回调函数。

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第48张图片

继续执行到private static final EnhancerKey KEY_FACTORY = (EnhancerKey) KeyFactory.create(EnhancerKey.class, KeyFactory.HASH_ASM_TYPE, null);这行

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第49张图片

这句的作用是使用key工厂创建出对应class的代理类,后面的KeyFactory_HASH_ASM_TYPE即代理类中创建HashCode方法的策略

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第50张图片

而且在此处出现了两个对象:KeyFactory和EnhancerKey

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第51张图片

KeyFactory这个对象是生成处理多值键的类(多个键组合在一起的),用于Maps和Sets等集合中

而Enhancer是一个内部接口,由于ClassLoader的问题,只能是public的

创建EnhancerKey

我们进入KeyFactory的create()方法中,开始EnhancerKey对象的创建

再次进入return处的create()方法

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第52张图片

方法先创建了一个最简易的代理类生成器(只会生成HashCode()、equals()、toString()、newInstance()方法),然后设置接口类型,添加定制器,设置类加载器,最后调用gen.create()生成enhancerKey的代理类

于是我们再次进入create()方法

这个create()方法中的第一步设置了该生成器生成代理对象类的名字前缀;第二步调用了super的create()方法,终于!咱们的创建要开始叻( ̄∇ ̄)/

create()
【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第53张图片

获取到当前生成器的类加载器loader,定义一个Map类型的变量cache,并把CACHE赋值给cache

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第54张图片

通过cache.get(loader)获取ClassLoaderData类型的结果data,不过此时cache里并没有值(CACHE是当前类在一开始初始化的一个Map<ClassLoader, ClassLoaderData>类型的空集合的变量,所以此时cache也为空)

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第55张图片

所以继续执行,会开始执行下图中条件代码块中的逻辑

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第56张图片

即新建一个ClassLoaderData(loader)赋值给刚刚未获取到值的变量data

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第57张图片

此时点击step into,我们会来到ClassLoaderData类中的变量GET_KEY初始化的位置

这个GET_KEY是一个Function类型的变量

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第58张图片

可以看出,Function类型是一个函数式接口,提供一个apply()方法,传入一个对象返回一个对象

public Object apply(AbstractClassGenerator gen) {
   return gen.key;
}

在此处的作用就是传入一个AbstractClassGenerator类型的变量gen,返回gen.key(key的定义位置见下图)

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第59张图片

继续执行我们会进入ClassLoaderData的构造方法中,在这里为上面定义的变量赋值

new ClassLoaderData()
【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第60张图片

第一步先判断类加载器不能为空,为空则抛出IllegalArgumentException的异常;接着设置类加载器(用的是弱引用类型WeakReference,即在下次垃圾回收时就会进行回收);


引用的强软弱虚(引用的强弱关系依次递减)

  • 强引用(=):关系存在,即不会被垃圾回收机制回收(内存溢出抛异常也不会回收)

  • 软引用(SoftReference):内存不够会被回收(回收后仍然OOM才会抛异常)

  • 弱引用(WeakReference):无论内存够不够,垃圾收集器一工作就会被回收

  • 虚引用(PhantomReference):约等于没有引用关系(甚至无法通过虚引用获取到对象实例),只是会在被回收后发送一条系统通知


然后新建了一个回调函数,这个回调函数的作用是当缓存中没获取到值时,会调用传入默认生成器AbstractclassGenerator的生成代理类并返回;最后,新建一个LoadingCache类型的缓存类,赋值给变量generatedClasses(这就是一个类型的变量,在类的一开始定义的)

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第61张图片

而LoadingCache中有两个参数,一个是GET_KEY(就是刚刚解释的那个会返回gen.key的函数式接口),还有一个是load,而这个load也是一个function类型的函数式接口,返回的是一个gen.wrapCachedClass(klass)对象,其实也就是一个Class类型的对象

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第62张图片

即此缓存对象中包含的两个具体的function对象(其实就是具体的业务逻辑处理过程)

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第63张图片

执行完构造函数返回,赋值给data,并放入缓存中

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第64张图片

此时我们的ClassLoaderData类型的变量data中包含了两个变量:一个key值和一个Class类型的对象,而这个对象被放入了CACHE中,因此此时CACHE中有了一个键值对

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第65张图片

设置一个key值

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第66张图片

紧接着通过刚创建的data中调用get方法并将当前生成器以及是否使用缓存的标识(系统参数System.getProperty("cglib.useCache","true"))传入进去,返回的是生成好的代理类的class信息

get()
【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第67张图片

进入get()方法中

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第68张图片

如果不使用缓存,则直接调用生成器的命令

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第69张图片

不过一般都是默认使用缓存的(即getUserCache()返回的值为true),于是会将生成器作为参数传入到generatedClasses的get()方法中

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第70张图片

可以看到此处的keyMapper就是在前面步骤中初始化好的ClassLoaderData

返回的值就是gen.key,由于map为空,所以v值为null,于是进入到this.createEntry(key, cacheKey, v)方法中

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第71张图片

由于v值为null,所以会进入else的代码块,新建一个FutureTask对象为task赋值,而FutureTask对象中是一个lambda表达式,调用一个call()方法,返回LoadingCache.this.loader.apply()

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第72张图片

不知道大家对LoadingCache还有没有印象,之前初始化ClassLoaderData对象时,给变量generatedClasses赋的值就是一个LoadingCache对象,当时里面传入的两个参数,一个是GET_KEY(其实就是gen.key),一个是load,此处调用的LoadingCache.this.loader就是指的这个对象

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第73张图片

因此调用LoadingCache.this.loader的apply()方法实际就是调用load这个lambda表达式中的apply()方法

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第74张图片

所以在执行到task.run()时,会调用执行call()方法

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第75张图片

点击step into进入run()方法,就会发现代码又执行到了刚才赋值的位置

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第76张图片

再次点击step into,就会跳转到LoadingCache.this.loader.apply()方法中

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第77张图片

在此处调用执行的generate()方法,就是实际生成字节码文件的方法

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第78张图片

先将当前的代理类生成器存入变量CURRENT中,CURRENT是一个ThreadLocal类型的变量(如下图)

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第79张图片

然后从传入的ClassLoaderData中获取类加载器classLoader,判断其是否为空,为空则抛出IllegalStateException异常;不为空则继续执行后面的逻辑

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第80张图片

在获取到类加载器后,我们还需要获取到代理类的名字,于是generateClassName()方法开始生成代理类的名字

getClassName()方法中是具体的生成规则(这点要比JDK生成代理对象名称要复杂,JDK就是获取包名,然后加“$Proxy”+0、1、2、3……)

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第81张图片

可以看下这次最终生成的代理类的名字

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第82张图片

有了名字后,回到generate()方法中将它缓存进传入的变量data中,有了类加载器,有了名字,接下来就开始生成字节码了

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第83张图片
【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第84张图片

进入generateClass()方法中,在这里为字节码文件写入方法

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第85张图片

先创建了一个ClassEmitter对象,尝试获取被代理类的newInstance()方法,如果没有会报异常(由此可知,如果想用Generator代理类生成器,newInstance()方法必不可少)此处我们代理的Enchaer、EnhancerKey、newInstance方法返回值为Object

接着找到newInstance()方法的所有参数类型放入集合parameterTypes中当做成员变量

接下来开始具体的写入操作

先通过begin_class()创建类开始写入类头,版本号,访问权限,类名等通用信息;接着调用EmitUtils.null_constructor()写入无参构造方法;调用EmitUtils.factory_method()写入newInstance()方法

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第86张图片

随后调用ce.begin_method()开始构造有参构造方法

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第87张图片
  1. 有参构造中调用父类构造方法(即super.构造方法())

  1. 找到传入的定制器(例如一开始传入的hashCode()方法定制器)

  1. 遍历成员变量(即newInstance()方法的所有参数)

  1. 将这些参数全部声明写入到类中

  1. 设置每个成员变量的值(this.xxx=xxx)

设置返回值,至此完成有参构造及成员变量的写入

最后还有一些Object的固定方法需要写入(包括hashcode()、equals()、toString())

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第88张图片

最后执行到ce.end_class(),类写入结束,至此类信息收集完成并全部写入ClassEmitter类型的变量ce中

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第89张图片

方法结束,返回字节码

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第90张图片

通过类加载器加载到内存,返回到apply()方法中

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第91张图片

获取generatedClasses的get()方法的返回值后,解包装并返回

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第92张图片

此时的cachedValue就有值了,返回给我们的obj

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第93张图片

在get()方法执行结束后,会判断获取到Object对象是否为Class的实例对象,由于Class类型的对象我们是没有办法直接使用的,所以需要通过调用firstInstance()方法进行实例化

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第94张图片

如果为Class则实例化并返回我们需要的代理类,如果不是则说明是实体,则直接执行另一个方法返回实体。create()执行结束后一路返回

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第95张图片

继续执行完后面的静态代码块就会回到我们的测试启动类,紧接着对superclass和callback两个属性进行赋值

【保姆级】手把手捋动态代理流程(JDK+Cglib超详细源码分析)_第96张图片

你可能感兴趣的:(Java,java,源码,动态代理,JDK,Cglib)