动态代理

Posted 2020-11-02 Mr.袋鼠

这是动态原理的第二篇，这里要讲述的是Cglib的东东。接下来，进正题。

参考文章：http://www.cnblogs.com/cruze/p/3843996.html

 

一、Cglib

CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。

二、Cglib原理

动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。它比使用java反射的JDK动态代理要快。

三、实例分析

分析前，我用一句话来概括Cglib的过程。首先将被代理类TargetObject设置成父类，然后设置拦截器TargetInterceptor，最后执行enhancer.create()动态生成一个代理类，并从Object强制转型成父类型TargetObject。

1.demo（注：示例代码我是从别的地方copy过来的，哪里来的我把地址忘了，所以没有贴上连接。但是后面的源码分析的部分，是自己一点点分析记录的。）

1 package com.lee.demo.springSourceLearn.demo;
2 
3 public class BookEditImpl {  
4     public void addBook() {  
5         System.out.println("add Book...");  
6     }  
7 }  

 1 import java.lang.reflect.Method;
 2 
 3 import org.springframework.cglib.proxy.Enhancer;
 4 import org.springframework.cglib.proxy.MethodInterceptor;
 5 import org.springframework.cglib.proxy.MethodProxy;
 6 
 7 public class BookFacadeCglib implements MethodInterceptor {  
 8     private Object target;//业务类对象，供代理方法中进行真正的业务方法调用
 9   
10     //相当于JDK动态代理中的绑定
11     public Object getInstance(Object target) {  
12         this.target = target;  //给业务对象赋值
13         Enhancer enhancer = new Enhancer(); //创建加强器，用来创建动态代理类
14         enhancer.setSuperclass(this.target.getClass());  //为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）
15         //设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦
16         enhancer.setCallback(this); 
17        // 创建动态代理类对象并返回  
18        return enhancer.create(); 
19     }
20     // 实现回调方法 
21     public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { 
22         System.out.println("预处理——————");
23         proxy.invokeSuper(obj, args); //调用业务类（父类中）的方法
24         System.out.println("调用后操作——————");
25         return null; 
26     } 
27 }

1 public class Test02 {
2 
3     public static void main(String[] args) {    
　　　　　　　　　// 生成的class文件默认只存储在内存中，我们可以在代码中加入下面语句来获取class file
　　　　　　　　 System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "C:\\\\Users\\\\lihao\\\\git");
4         BookEditImpl bookFacade=new BookEditImpl();
5         BookFacadeCglib  cglib=new BookFacadeCglib();  
6         BookEditImpl bookCglib=(BookEditImpl)cglib.getInstance(bookFacade);  
7         bookCglib.addBook();  
8     }  
9 }

运行执行结果如下：

预处理——————
add Book...
调用后操作——————

2.过程分析

首先getInstance中会先进行父类和回调方法的设置，接下来，进入enhancer.create的方法。

1     public Object create() {
　　　　　　　　　// 下面两行暂时不知道属性的作用，暂且放下，进入方法继续探索
2         this.classOnly = false;
3         this.argumentTypes = null;
4         return this.createHelper();
5     }

 

 1 private Object createHelper() {
　　　　　　　　　　// 进行有效性验证，比如有多个callBack却没有callBackFilter
 2         this.validate();
 3         if (this.superclass != null) {
　　　　　　　　　　　　　// 前面已经设置了superClass，所以会进到这个分支里来
 4             this.setNamePrefix(this.superclass.getName());
 5         } else if (this.interfaces != null) {
 6             this.setNamePrefix(this.interfaces[ReflectUtils.findPackageProtected(this.interfaces)].getName());
 7         }
 8 
　　　　　　　　　 // KEY_FACTORY根据代理类的组合信息，生成一个组合key，这个key用在后面的缓存的地方
           // 为什么会用到缓存呢？ 因为我们调用一个类中的某个方法，就会生成一个代理类，再调用类的另一个方法时，代理类已经存在了，就不要再重复创建了，因此便有了缓存的想法。
　　　　　　　　　　// 父类： public class Enhancer extends AbstractClassGenerator 
 9         return super.create(KEY_FACTORY.newInstance(this.superclass != null ? this.superclass.getName() : null,
10                 ReflectUtils.getNames(this.interfaces), this.filter, this.callbackTypes, this.useFactory,
11                 this.interceptDuringConstruction, this.serialVersionUID));
12     }

 

 1 protected Object create(Object key) {
 2         try {
 3             Class e = null;
 4             Source arg2 = this.source;
 5             synchronized (this.source) {
　　　　　　　　　　　　　　　　 // 生成类的缓存是按照ClassLoader来区分的，因为类的区分是按照类名和ClassLoader两者组合来区分的，同样的类名，不同的ClassLodaer,那么类也是不同的
 6                 ClassLoader loader = this.getClassLoader();
 7                 Object cache2 = null;
　　　　　　　　　　　　　　　　 // cache数据结构 Map<ClassLaodaer,Map<nameKey，HashSet>>
 8                 cache2 = (Map) this.source.cache.get(loader);
 9                 if (cache2 == null) {
10                     cache2 = new HashMap();
11                     ((Map) cache2).put(NAME_KEY, new HashSet());
12                     this.source.cache.put(loader, cache2);
13                 } else if (this.useCache) {
14                     Reference save = (Reference) ((Map) cache2).get(key);
15                     e = (Class) (save == null ? null : save.get());
16                 }
17 
18                 if (e == null) {
19                     Object save1 = CURRENT.get();
20                     CURRENT.set(this);
21 
22                     Object b1;
23                     try {
24                         this.key = key;
                           // debug的时候发现这个attemptLoad值为false，就不会进入这个分支，接下来进入到e=null里面
25                         if (this.attemptLoad) {
26                             try {
27                                 e = loader.loadClass(this.getClassName());
28                             } catch (ClassNotFoundException arg16) {
29                                 ;
30                             }
31                         }
32 
33                         if (e == null) {
　　　　　　　　　　　　　　　　　　　　　　　　　　　// 代理类生成的操作，使用相应的策略生成34                             byte[] b = this.strategy.generate(this);
35                             String className = ClassNameReader.getClassName(new ClassReader(b));
36                             this.getClassNameCache(loader).add(className);
37                             e = ReflectUtils.defineClass(className, b, loader);
38                         }
39 
40                         if (this.useCache) {
41                             ((Map) cache2).put(key, new WeakReference(e));
42                         }
43 
44                         b1 = this.firstInstance(e);
45                     } finally {
46                         CURRENT.set(save1);
47                     }
48 
49                     return b1;
50                 }
51             }
52 
53             return this.firstInstance(e);
54         } catch (RuntimeException arg19) {
55             throw arg19;
56         } catch (Error arg20) {
57             throw arg20;
58         } catch (Exception arg21) {
59             throw new CodeGenerationException(arg21);
60         }
61     }

下面代码一共三行，但是东西是真心不少啊！一行行分析。有时代码越少，越难

1 public byte[] generate(ClassGenerator cg) throws Exception {
2         DebuggingClassWriter cw = this.getClassVisitor();
3         this.transform(cg).generateClass(cw);
4         return this.transform(cw.toByteArray());
5     }

getClassVisitor

1 protected DebuggingClassWriter getClassVisitor() throws Exception {
2         return new DebuggingClassWriter(1);
3     }

DebuggingClassWriter 关注下面标红的部分

 1 public class DebuggingClassWriter extends ClassVisitor {
 2     public static final String DEBUG_LOCATION_PROPERTY = "cglib.debugLocation";
 3     private static String debugLocation = System.getProperty("cglib.debugLocation");
 4     private static Constructor traceCtor;
 5     private String className;
 6     private String superName;
 7 
 8     public DebuggingClassWriter(int flags) {
 9         super(262144, new ClassWriter(flags));
10     }
11 
12     public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
13         this.className = name.replace(\'/\', \'.\');
14         this.superName = superName.replace(\'/\', \'.\');
15         super.visit(version, access, name, signature, superName, interfaces);
16     }
17 
18     public String getClassName() {
19         return this.className;
20     }
21 
22     public String getSuperName() {
23         return this.superName;
24     }
25 
26     public byte[] toByteArray() {
27       return (byte[])((byte[])AccessController.doPrivileged(new 1(this)));
28    }
29 
30     static {
　　　　　　　　　　// 通过这里就能知道，如何生成CGLIB动态代理类到本地
31         if (debugLocation != null) {
32             System.err.println("CGLIB debugging enabled, writing to \\\'" + debugLocation + "\\\'");
33 
34             try {
35                 Class ignore = Class.forName("org.springframework.asm.util.TraceClassVisitor");
36                 traceCtor = ignore
37                         .getConstructor(new Class[]{
38                                 class$org$objectweb$asm$ClassVisitor == null
39                                         ? (class$org$objectweb$asm$ClassVisitor = class$(
40                                                 "org.springframework.asm.ClassVisitor"))
41                                         : class$org$objectweb$asm$ClassVisitor,
42                                 class$java$io$PrintWriter == null
43                                         ? (class$java$io$PrintWriter = class$("java.io.PrintWriter"))
44                                         : class$java$io$PrintWriter});
45             } catch (Throwable arg0) {
46                 ;
47             }
48         }
49 
50     }
51 }

回到generate方法，

1 protected ClassGenerator transform(ClassGenerator cg) throws Exception {
2         return cg;
3     }

1 public interface ClassGenerator {
2     void generateClass(ClassVisitor arg0) throws Exception;
3 }

那么，generateClass的实现类的方法是哪个呢？

public class Enhancer extends AbstractClassGenerator

public abstract class AbstractClassGenerator implements ClassGenerator

最后回归到Enhancer这个类中。。。

我们接下来回到上文create方法中的44行接着分析。（可能会有些跳跃性，因为有些地方无法一句句分析到，请谅解。写到这里为止，花了三个半小时，写过长的博客，也慢慢懂得前辈们优秀的文章中是包含了好多的心血，读起来，去理解消化也绝非是一蹴而就的事情。）

 b1 = this.firstInstance(e);

这一行调用了firstInstance方法，它是一个模板方法（空方法），在Enhancer类中实现了方法

 

1 protected Object firstInstance(Class type) throws Exception {
　　　　　　　　　// 在前文create方法中，将classOnly设置为false，因此进入到后面的分支
　　　　　　　　　// 建议简单的东西可以写三元运算符，复杂的东西不要用三元，因为一是容易出错，二是debug不方便
2         return this.classOnly ? type : this.createUsingReflection(type);
3     }

用反射创建实例，下面代码比较简单，大部分看名字就能知道其作用，我们着重看一下setThreadCallbacks方法，这里为了设置回调方法

 1 private Object createUsingReflection(Class type) {
 2         setThreadCallbacks(type, this.callbacks);
 3 
 4         Object arg1;
 5         try {
 6             if (this.argumentTypes != null) {
 7                 arg1 = ReflectUtils.newInstance(type, this.argumentTypes, this.arguments);
 8                 return arg1;
 9             }
10 
11             arg1 = ReflectUtils.newInstance(type);
12         } finally {
13             setThreadCallbacks(type, (Callback[]) null);
14         }
15 
16         return arg1;
17     }

 

 1 private static void setThreadCallbacks(Class type, Callback[] callbacks) {
 2         setCallbacksHelper(type, callbacks, "CGLIB$SET_THREAD_CALLBACKS");
 3     }
 4 
 5 
 6 private static void setCallbacksHelper(Class type, Callback[] callbacks, String methodName) {
 7         try {
 8             Method e = getCallbacksSetter(type, methodName);
 9             e.invoke((Object) null, new Object[]{callbacks});
10         } catch (NoSuchMethodException arg3) {
11             throw new IllegalArgumentException(type + " is not an enhanced class");
12         } catch (IllegalAccessException arg4) {
13             throw new CodeGenerationException(arg4);
14         } catch (InvocationTargetException arg5) {
15             throw new CodeGenerationException(arg5);
16         }
17     }

这个方法中的内容，不明白，如果有明白的朋友，请您告诉我。！！！

1 private static Method getCallbacksSetter(Class type, String methodName) throws NoSuchMethodException {
2         return type
3                 .getDeclaredMethod(methodName,
4                         new Class[]{array$Lnet$sf$cglib$proxy$Callback == null
5                                 ? (array$Lnet$sf$cglib$proxy$Callback = class$(
6                                         "[Lorg.springframework.cglib.proxy.Callback;"))
7                                 : array$Lnet$sf$cglib$proxy$Callback});
8     }

暂且写到这里了，自己感觉后部分，有许多东西，写的不透彻，原因是自己也没有百分百理解好，导致了这个现象，惭愧!!!

继续努力，fighting！！！