Spring 5.x 源码之旅-11模拟Spring的CGLIB动态代理生成字节码

      	@Test
        public void cglibTest() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
            //反射出ConfigurationClassEnhancer，并创建实例
            Class<?> configurationClassEnhancerClass = Class.forName("org.springframework.context.annotation.ConfigurationClassEnhancer");
            Constructor constructor = configurationClassEnhancerClass.getDeclaredConstructor();
            constructor.setAccessible(true);
            Object configurationClassEnhancer = constructor.newInstance();
    
            //获取属性callbackFilter
            Field callbackFilterField = configurationClassEnhancerClass.getDeclaredField("CALLBACK_FILTER");
            callbackFilterField.setAccessible(true);
            CallbackFilter callbackFilter = (CallbackFilter) callbackFilterField.get(configurationClassEnhancer);
    
            //反射ConditionalCallbackFilter类
            Class<?> ConditionalCallbackFilter = Class.forName("org.springframework.context.annotation.ConfigurationClassEnhancer$ConditionalCallbackFilter");
            //获取getCallbackTypes方法
            Method getCallbackTypesMethod = ConditionalCallbackFilter.getDeclaredMethod("getCallbackTypes");
            getCallbackTypesMethod.setAccessible(true);
            
            
            //反射出EnhancedConfiguration接口
            Class<?> enhancedConfiguration = Class.forName("org.springframework.context.annotation.ConfigurationClassEnhancer$EnhancedConfiguration");
    
            //创建增强类
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(MyConfig.class);//设置目标类
            enhancer.setInterfaces(new Class<?>[]{enhancedConfiguration});//设置要实现的接口
            enhancer.setUseFactory(false);
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            enhancer.setStrategy(new MyBeanFactoryAwareGeneratorStrategy(this.getClass().getClassLoader()));//生成自定义的策略
            //过滤器
            enhancer.setCallbackFilter(callbackFilter);
            //过滤器类型
            enhancer.setCallbackTypes((Class[]) getCallbackTypesMethod.invoke(callbackFilter));
            //创建代理类
            Class proxy = enhancer.createClass();
            System.out.println(proxy);
        }

MyBeanFactoryAwareGeneratorStrategy扩展策略

我们的扩展策略，因为我要把他的二进制字节码保存到本地查看，所以要扩展，而且我把增加的属性名改成自定义的bean工厂，我只是为了演示才这样的啊，然后将保存到本地的代码加进去：

    public  class MyBeanFactoryAwareGeneratorStrategy extends DefaultGeneratorStrategy {
    
    		private final ClassLoader classLoader;
    
    		public MyBeanFactoryAwareGeneratorStrategy(ClassLoader classLoader) {
    			this.classLoader = classLoader;
    		}
    
    		@Override
    		protected ClassGenerator transform(ClassGenerator cg) throws Exception {
    			ClassEmitterTransformer transformer = new ClassEmitterTransformer() {
    				@Override
    				public void end_class() {
    					declare_field(Constants.ACC_PUBLIC, "自定义的bean工厂", Type.getType(BeanFactory.class), null);
    					super.end_class();
    				}
    			};
    			return new TransformingClassGenerator(cg, transformer);
    		}
    
    		@Override
    		public byte[] generate(ClassGenerator cg) throws Exception {
    			if (this.classLoader == null) {
    				return super.generate(cg);
    			}
    
    			Thread currentThread = Thread.currentThread();
    			ClassLoader threadContextClassLoader;
    			try {
    				threadContextClassLoader = currentThread.getContextClassLoader();
    			}
    			catch (Throwable ex) {
    				// Cannot access thread context ClassLoader - falling back...
    				return super.generate(cg);
    			}
    
    			boolean overrideClassLoader = !this.classLoader.equals(threadContextClassLoader);
    			if (overrideClassLoader) {
    				currentThread.setContextClassLoader(this.classLoader);
    			}
    			try {
    				//生成的字节码保存到本地
                    byte[] generate = super.generate(cg);
                    FileOutputStream fileOutputStream = null;
                    try {
                        fileOutputStream = new FileOutputStream(new File("D:\\MyConfigProxy.class"));
                        try {
                            fileOutputStream.write(generate);
                        } catch (IOException e) {
                            e.printStackTrace();
                        } finally {
                            if (fileOutputStream != null) {
                                try {
                                    fileOutputStream.flush();
                                    fileOutputStream.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    }
    
                    return generate;
    			}
    			finally {
    				if (overrideClassLoader) {
    					// Reset original thread context ClassLoader.
    					currentThread.setContextClassLoader(threadContextClassLoader);
    				}
    			}
    		}
    	}

被代理类

我们要增强的配置类：

结果：

可以看到前面的属性自定义的bean工厂被加进去了，CGLIB继承了目标类，实现了设置的接口。

增强的方法：

我们来看这段代码，首先会有个拦截器MethodInterceptor ，返回什么是要执行拦截器的方法的，如果拦截器不存在，才会去调用父类的userDao，我猜这里应该是为了单例来拦截，去查$$beanFactory里是否有实例，有就直接返回，没有才去创建，不然每次都调用会生成一个新的实例：

        final UserDao CGLIB$userDao$0() {
            return super.userDao();
        }
    
        public final UserDao userDao() {
            MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
            if (var10000 == null) {
                CGLIB$BIND_CALLBACKS(this);
                var10000 = this.CGLIB$CALLBACK_0;
            }
    
            return var10000 != null ? (UserDao)var10000.intercept(this, CGLIB$userDao$0$Method, CGLIB$emptyArgs, CGLIB$userDao$0$Proxy) : super.userDao();
        }

对EnhancedConfiguration的setBeanFactory方法也进行了拦截：