搜索

你必须会的 JDK 动态代理和 CGLIB 动态代理

源码共读

共 11439字，需浏览 23分钟

 ·

2021-01-24 19:31

Python实战社群

Java实战社群

长按识别下方二维码，按需求添加

扫码关注添加客服

进Python社群▲

扫码关注添加客服

进Java社群▲


作者丨ytao

来源丨ytao


我们在阅读一些 Java 框架的源码时，基本上常会看到使用动态代理机制，它可以无感的对既有代码进行方法的增强，使得代码拥有更好的拓展性。通过从静态代理、JDK 动态代理、CGLIB 动态代理来进行本文的分析。

静态代理

静态代理就是在程序运行之前，代理类字节码 .class就已编译好，通常一个静态代理类也只代理一个目标类，代理类和目标类都实现相同的接口。接下来就先通过 demo 进行分析什么是静态代理，当前创建一个 Animal 接口，里面包含 call函数。

  1. package top.ytao.demo.proxy;

  3. /**
  4.  * Created by YangTao
  5.  */
  6. publicinterfaceAnimal{

  8. void call();

  10. }

创建目标类 Cat，同时实现 Animal 接口，下面是 Cat 发出叫声的实现。

  1. package top.ytao.demo.proxy;

  3. /**
  4.  * Created by YangTao
  5.  */
  6. publicclassCatimplementsAnimal{

  8. @Override
  9. publicvoid call() {
  10. System.out.println("喵喵喵 ~");
  11. }
  12. }

由于 Cat 叫之前是因为肚子饿了，所以我们需要在目标对象方法 Cat#call之前说明是饥饿，这是使用静态代理实现猫饥饿然后发出叫声。

  1. package top.ytao.demo.proxy.jdk;

  3. import top.ytao.demo.proxy.Animal;

  5. /**
  6.  * Created by YangTao
  7.  */
  8. publicclassStaticProxyAnimalimplementsAnimal{

  10. privateAnimal impl;

  12. publicStaticProxyAnimal(Animal impl) {
  13. this.impl = impl;
  14. }

  16. @Override
  17. publicvoid call() {
  18. System.out.println("猫饥饿");
  19.         impl.call();
  20. }
  21. }

通过调用静态代理实现猫饥饿和叫行为。

  1. publicclassMain{

  3. @Test
  4. publicvoid staticProxy(){
  5. Animal staticProxy = newStaticProxyAnimal(newCat());
  6.         staticProxy.call();
  7. }
  8. }

执行结果

代理类、目标类、接口之间关系如图：

以上内容可以看到代理类中通过持有目标类对象，然后通过调用目标类的方法，实现静态代理。静态代理虽然实现了代理，但在一些情况下存在比较明显不足之处：

  1. 当我们在 Animal 接口中增加方法，这时不仅实现类 Cat 需要新增该方法的实现，同时，由于代理类实现了 Animal 接口，所以代理类也必须实现 Animal 新增的方法，这对项目规模较大时，在维护上就不太友好了。

  2. 代理类实现 Animal#call是针对 Cat 目标类的对象进行设置的，如果再需要添加 Dog 目标类的代理，那就必须再针对 Dog 类实现一个对应的代理类，这样就使得代理类的重用型不友好，并且过多的代理类对维护上也是比较繁琐。

上面问题，在 JDk 动态代理中就得到了较友好的解决。

JDK 动态代理

动态代理类与静态代理类最主要不同的是，代理类的字节码不是在程序运行前生成的，而是在程序运行时再虚拟机中程序自动创建的。继续用上面 Cat 类和 Animal 接口实现 JDK 动态代理。

实现 InvocationHandler 接口

JDK 动态代理类必须实现反射包中的 java.lang.reflect.InvocationHandler 接口，在此接口中只有一个 invoker 方法：

在 InvocationHandler#invoker中必须调用目标类被代理的方法，否则无法做到代理的实现。下面为实现 InvocationHandler 的代码。

  1. /**
  2.  * Created by YangTao
  3.  */
  4. publicclassTargetInvokerimplementsInvocationHandler{
  5. // 代理中持有的目标类
  6. privateObject target;

  8. publicTargetInvoker(Object target) {
  9. this.target = target;
  10. }

  12. @Override
  13. publicObject invoke(Object proxy, Method method, Object[] args) throwsThrowable{
  14. System.out.println("jdk 代理执行前");
  15. Object result = method.invoke(target, args);
  16. System.out.println("jdk 代理执行后");
  17. return result;
  18. }
  19. }

在实现 InvocationHandler#invoker时，该方法里有三个参数：

  • proxy 代理目标对象的代理对象，它是真实的代理对象。

  • method 执行目标类的方法

  • args 执行目标类的方法的参数

创建 JDK 动态代理类

创建 JDK 动态代理类实例同样也是使用反射包中的 java.lang.reflect.Proxy 类进行创建。通过调用 Proxy#newProxyInstance静态方法进行创建。

  1. /**
  2.  *
  3.  * Created by YangTao
  4.  */
  5. publicclassDynamicProxyAnimal{

  7. publicstaticObject getProxy(Object target) throwsException{
  8. Object proxy = Proxy.newProxyInstance(
  9.                 target.getClass().getClassLoader(), // 指定目标类的类加载
  10.                 target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个，这是一个数组
  11. newTargetInvoker(target)   // 代理对象处理器
  12. );
  13. return proxy;
  14. }

  16. }

Proxy#newProxyInstance中的三个参数（ClassLoader loader、Class[] interfaces、InvocationHandler h）：

  • loader 加载代理对象的类加载器

  • interfaces 代理对象实现的接口，与目标对象实现同样的接口

  • h 处理代理对象逻辑的处理器，即上面的 InvocationHandler 实现类。

最后实现执行 DynamicProxyAnimal 动态代理：

  1. publicclassMain{

  3. @Test
  4. publicvoid dynamicProxy() throwsException{
  5. Cat cat = newCat();
  6. Animal proxy = (Animal) DynamicProxyAnimal.getProxy(cat);
  7.         proxy.call();
  8. }
  9. }

执行结果：

通过上面的代码，有两个问题：代理类是怎么创建的和代理类怎么调用方法的？

分析

从 Proxy#newProxyInstance入口进行源码分析：

  1. publicstaticObject newProxyInstance(ClassLoader loader,
  2. Class[] interfaces,
  3. InvocationHandler h)
  4. throwsIllegalArgumentException
  5. {
  6. Objects.requireNonNull(h);

  8. finalClass[] intfs = interfaces.clone();
  9. finalSecurityManager sm = System.getSecurityManager();
  10. if(sm != null) {
  11.         checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
  12. }

  14. // 查找或生成指定的代理类
  15. Class cl = getProxyClass0(loader, intfs);

  17. try{
  18. if(sm != null) {
  19.             checkNewProxyPermission(Reflection.getCallerClass(), cl);
  20. }

  22. // 获取代理的构造器
  23. finalConstructor cons = cl.getConstructor(constructorParams);
  24. finalInvocationHandler ih = h;
  25. // 处理代理类修饰符，使得能被访问
  26. if(!Modifier.isPublic(cl.getModifiers())) {
  27. AccessController.doPrivileged(newPrivilegedAction<Void>() {
  28. publicVoid run() {
  29.                     cons.setAccessible(true);
  30. returnnull;
  31. }
  32. });
  33. }
  34. // 创建代理类实例化
  35. return cons.newInstance(newObject[]{h});
  36. } catch(IllegalAccessException|InstantiationException e) {
  37. thrownewInternalError(e.toString(), e);
  38. } catch(InvocationTargetException e) {
  39. Throwable t = e.getCause();
  40. if(t instanceofRuntimeException) {
  41. throw(RuntimeException) t;
  42. } else{
  43. thrownewInternalError(t.toString(), t);
  44. }
  45. } catch(NoSuchMethodException e) {
  46. thrownewInternalError(e.toString(), e);
  47. }
  48. }

newProxyInstance 方法里面获取到代理类，如果类的作用不能访问，使其能被访问到，最后实例化代理类。这段代码中最为核心的是获取代理类的 getProxyClass0方法。

  1. privatestaticfinalWeakCache<ClassLoader, Class[], Class> proxyClassCache = newWeakCache<>(newKeyFactory(), newProxyClassFactory());

  3. privatestaticClass getProxyClass0(ClassLoader loader,
  4. Class... interfaces) {
  5. // 实现类的接口不能超过 65535 个
  6. if(interfaces.length > 65535) {
  7. thrownewIllegalArgumentException("interface limit exceeded");
  8. }

  10. // 获取代理类
  11. return proxyClassCache.get(loader, interfaces);
  12. }

如果 proxyClassCache 缓存中存在指定的代理类，则从缓存直接获取；如果不存在，则通过 ProxyClassFactory 创建代理类。至于为什么接口最大为 65535，这个是由字节码文件结构和 Java 虚拟机规定的，具体可以通过研究字节码文件了解。

进入到 proxyClassCache#get，获取代理类:

继续进入 Factory#get查看，

最后到 ProxyClassFactory#apply，这里实现了代理类的创建。

  1. privatestaticfinalclassProxyClassFactoryimplementsBiFunction<ClassLoader, Class[], Class>{
  2. // 所有代理类名称都已此前缀命名
  3. privatestaticfinalString proxyClassNamePrefix = "$Proxy";

  5. // 代理类名的编号
  6. privatestaticfinalAtomicLong nextUniqueNumber = newAtomicLong();

  8. @Override
  9. publicClass apply(ClassLoader loader, Class[] interfaces) {

  11. Map<Class, Boolean> interfaceSet = newIdentityHashMap<>(interfaces.length);
  12. for(Class intf : interfaces) {

  14. // 校验代理和目标对象是否实现同一接口
  15. Class interfaceClass = null;
  16. try{
  17.                 interfaceClass = Class.forName(intf.getName(), false, loader);
  18. } catch(ClassNotFoundException e) {
  19. }
  20. if(interfaceClass != intf) {
  21. thrownewIllegalArgumentException(
  22.                     intf + " is not visible from class loader");
  23. }

  25. // 校验 interfaceClass 是否为接口
  26. if(!interfaceClass.isInterface()) {
  27. thrownewIllegalArgumentException(
  28.                     interfaceClass.getName() + " is not an interface");
  29. }

  31. // 判断当前 interfaceClass 是否被重复
  32. if(interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
  33. thrownewIllegalArgumentException(
  34. "repeated interface: "+ interfaceClass.getName());
  35. }
  36. }

  38. // 代理类的包名
  39. String proxyPkg = null;     
  40. int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

  42. // 记录非 public 修饰符代理接口的包，使生成的代理类与它在同一个包下
  43. for(Class intf : interfaces) {
  44. int flags = intf.getModifiers();
  45. if(!Modifier.isPublic(flags)) {
  46.                 accessFlags = Modifier.FINAL;
  47. // 获取接口类名
  48. String name = intf.getName();
  49. // 去掉接口的名称，获取所在包的包名
  50. int n = name.lastIndexOf('.');
  51. String pkg = ((n == -1) ? "": name.substring(0, n + 1));
  52. if(proxyPkg == null) {
  53.                     proxyPkg = pkg;
  54. } elseif(!pkg.equals(proxyPkg)) {
  55. thrownewIllegalArgumentException(
  56. "non-public interfaces from different packages");
  57. }
  58. }
  59. }

  61. if(proxyPkg == null) {
  62. // 如果接口类是 public 修饰，则用 com.sun.proxy 包名
  63.             proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
  64. }

  66. // 创建代理类名称
  67. long num = nextUniqueNumber.getAndIncrement();
  68. String proxyName = proxyPkg + proxyClassNamePrefix + num;

  70. // 生成代理类字节码文件
  71. byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
  72.             proxyName, interfaces, accessFlags);
  73. try{
  74. // 加载字节码，生成指定代理对象
  75. return defineClass0(loader, proxyName,
  76.                                 proxyClassFile, 0, proxyClassFile.length);
  77. } catch(ClassFormatError e) {
  78. thrownewIllegalArgumentException(e.toString());
  79. }
  80. }
  81. }

以上就是创建字节码流程，通过检查接口的属性，决定代理类字节码文件生成的包名及名称规则，然后加载字节码获取代理实例。操作生成字节码文件在 ProxyGenerator#generateProxyClass中生成具体的字节码文件，字节码操作这里不做详细讲解。 

生成的字节码文件，我们可以通过保存本地进行反编译查看类信息，保存生成的字节码文件可以通过两种方式：设置jvm参数或将生成 byte[] 写入文件。

上图的 ProxyGenerator#generateProxyClass方法可知，是通过 saveGeneratedFiles 属性值控制，该属性的值来源：

  1. privatestaticfinalboolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(newGetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();

所以通过设置将生成的代理类字节码保存到本地。

  1. -Dsun.misc.ProxyGenerator.saveGeneratedFiles=true

反编译查看生成的代理类：

生成的代理类继承了 Proxy 和实现了 Animal 接口，调用 call方法，是通过调用 Proxy 持有的 InvocationHandler 实现 TargetInvoker#invoker的执行。

CGLIB 动态代理

CGLIB 动态代理的实现机制是生成目标类的子类，通过调用父类（目标类）的方法实现，在调用父类方法时再代理中进行增强。

实现 MethodInterceptor 接口

相比于 JDK 动态代理的实现，CGLIB 动态代理不需要实现与目标类一样的接口，而是通过方法拦截的方式实现代理，代码实现如下，首先方法拦截接口 net.sf.cglib.proxy.MethodInterceptor。

  1. /**
  2.  * Created by YangTao
  3.  */
  4. publicclassTargetInterceptorimplementsMethodInterceptor{

  6. @Override
  7. publicObject intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throwsThrowable{
  8. System.out.println("CGLIB 调用前");
  9. Object result = proxy.invokeSuper(obj, args);
  10. System.out.println("CGLIB 调用后");
  11. return result;
  12. }
  13. }

通过方法拦截接口调用目标类的方法，然后在该被拦截的方法进行增强处理，实现方法拦截器接口的 intercept 方法里面有四个参数：

  • obj 代理类对象

  • method 当前被代理拦截的方法

  • args 拦截方法的参数

  • proxy 代理类对应目标类的代理方法

创建 CGLIB 动态代理类

创建 CGLIB 动态代理类使用 net.sf.cglib.proxy.Enhancer 类进行创建，它是 CGLIB 动态代理中的核心类，首先创建个简单的代理类：

  1. /**
  2.  * Created by YangTao
  3.  */
  4. publicclassCglibProxy{

  6. publicstaticObject getProxy(Class clazz){
  7. Enhancer enhancer = newEnhancer();
  8. // 设置类加载
  9.         enhancer.setClassLoader(clazz.getClassLoader());
  10. // 设置被代理类
  11.         enhancer.setSuperclass(clazz);
  12. // 设置方法拦截器
  13.         enhancer.setCallback(newTargetInterceptor());
  14. // 创建代理类
  15. return enhancer.create();
  16. }

  18. }

设置被代理类的信息和代理类拦截的方法的回调执行逻辑，就可以实现一个代理类。实现 CGLIB 动态代理调用：

  1. publicclassMain{

  3. @Test
  4. publicvoid dynamicProxy() throwsException{
  5. Animal cat = (Animal) CglibProxy.getProxy(Cat.class);
  6.         cat.call();
  7. }
  8. }

执行结果：

CGLIB 动态代理简单应用就这样实现，但是 Enhancer 在使用过程中，常用且有特色功能还有回调过滤器 CallbackFilter 的使用，它在拦截目标对象的方法时，可以有选择性的执行方法拦截，也就是选择被代理方法的增强处理。使用该功能需要实现 net.sf.cglib.proxy.CallbackFilter 接口。现在增加一个方法拦截的实现：

  1. /**
  2.  * Created by YangTao
  3.  */
  4. publicclassTargetInterceptor2implementsMethodInterceptor{

  6. @Override
  7. publicObject intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throwsThrowable{
  8. System.out.println("CGLIB 调用前 TargetInterceptor2");
  9. Object result = proxy.invokeSuper(obj, args);
  10. System.out.println("CGLIB 调用后 TargetInterceptor2");
  11. return result;
  12. }
  13. }

然后在 Cat 中增加 hobby 方法，因为 CGLIB 代理无需实现接口，可以直接代理普通类，所以不需再 Animal 接口中增加方法：

  1. package top.ytao.demo.proxy;

  3. /**
  4.  * Created by YangTao
  5.  */
  6. publicclassCatimplementsAnimal{

  8. @Override
  9. publicvoid call() {
  10. System.out.println("喵喵喵 ~");
  11. }

  13. publicvoid hobby(){
  14. System.out.println("fish ~");
  15. }
  16. }

实现回调过滤器 CallbackFilter

  1. /**
  2.  * Created by YangTao
  3.  */
  4. publicclassTargetCallbackFilterimplementsCallbackFilter{
  5. @Override
  6. publicint accept(Method method) {
  7. if("hobby".equals(method.getName()))
  8. return1;
  9. else
  10. return0;
  11. }
  12. }

为演示调用不同的方法拦截器，在 Enhancer 设置中，使用 Enhancer#setCallbacks设置多个方法拦截器，参数是一个数组， TargetCallbackFilter#accept返回的数字即为该数组的索引，决定调用的回调选择器。

  1. /**
  2.  * Created by YangTao
  3.  */
  4. publicclassCglibProxy{

  6. publicstaticObject getProxy(Class clazz){
  7. Enhancer enhancer = newEnhancer();
  8.         enhancer.setClassLoader(clazz.getClassLoader());
  9.         enhancer.setSuperclass(clazz);
  10.         enhancer.setCallbacks(newCallback[]{newTargetInterceptor(), newTargetInterceptor2()});
  11.         enhancer.setCallbackFilter(newTargetCallbackFilter());
  12. return enhancer.create();
  13. }

  15. }

按代码实现逻辑，call 方法会调用 TargetInterceptor 类，hobby 类会调用 TargetInterceptor2 类，执行结果：

CGLIB 的实现原理是通过设置被代理的类信息到 Enhancer 中，然后利用配置信息在 Enhancer#create生成代理类对象。生成类是使用 ASM 进行生成，本文不做重点分析。如果不关注 ASM 的操作原理，只看 CGLIB 的处理原理还是比较容易读懂。这里主要看生成后的代理类字节码文件，通过设置

  1. System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "F:\\xxx");

可保存生成的字节到 F:\xxx 文件夹中

通过反编译可看到

代理类继承了目标类 Cat，同时将两个方法拦截器加载到了代理类中，通过 Callbacks 下标作为变量名后缀进行区分，最后调用指定的方法拦截器中的 intercept 实现代理的最终的执行结果。这里需要注意的是 CGLIB 动态代理不能代理 final 修饰的类和方法。

最后

通过反编译生成的 JDK 代理类和 CGLIB 代理类，我们可以看到它们两种不同机制的实现： 

JDK 动态代理是通过实现目标类的接口，然后将目标类在构造动态代理时作为参数传入，使代理对象持有目标对象，再通过代理对象的 InvocationHandler 实现动态代理的操作。 

CGLIB 动态代理是通过配置目标类信息，然后利用 ASM 字节码框架进行生成目标类的子类。当调用代理方法时，通过拦截方法的方式实现代理的操作。总的来说，JDK 动态代理利用接口实现代理，CGLIB 动态代理利用继承的方式实现代理。

动态代理在 Java 开发中是非常常见的，在日志，监控，事务中都有着广泛的应用，同时在大多主流框架中的核心组件中也是少不了使用的，掌握其要点，不管是开发还是阅读其他框架源码时，都是必须的。

程序员专栏
 扫码关注填加客服 
长按识别下方二维码进群

近期精彩内容推荐：  

 阿里彻底拆中台了！

 程序员相亲图鉴

 21 岁理工男开源的这个编辑器火了！

 996 违法？？？





在看点这里好文分享给更多人↓↓

浏览 17
点赞
评论
收藏
分享

手机扫一扫分享

举报
评论
图片
表情
推荐
Java动态代理的两种实现方法：JDK动态代理和CGLIB动态代理
java1234
0
Java中的原生动态代理和CGLIB动态代理的原理,我不信你全知道!
作者：CarpenterLeecnblogs.com/CarpenterLee/p/8241042.html动态代理在Java中有着广泛的应用，比如Spring AOP，Hibernate数据查询、测试框架的后端mock、RPC，Java注解对象获取等。静态代理的代理关系在编译时就确...
程序员私房菜
0
深入理解JDK动态代理
小哈学Java
0
CGLibJava 动态代理
CGLib(CodeGenerationLibrary)是一个强大的、高性能、高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。Hibernate用它来实现PO字节码的动态生成
CGLibJava 动态代理
0
这一次彻底搞懂JDK动态代理
JavaEdge
0
Java中的静态代理和动态代理
java1234
0
CGLibJava 动态代理
CGLib (Code Generation Library) 是一个强大的、高性能、高质量的 Co
CGLibJava 动态代理
0
DPIGGo 动态代理库
DPIG 是一个实验性质的 Go 语言动态代理库，它不依赖代码生成技术，可以对接口的实例进行动态增强
DPIGGo 动态代理库
0
​动态代理大揭秘，带你彻底弄清楚动态代理！
SegmentFault
0
关于Spring AOP，除了动态代理、CGLIB，你还知道什么？
java宝典
0
点赞
评论
收藏
分享

手机扫一扫分享

举报