随手记AOP如何避开BeanNotOfRequiredTypeException及CGLIB

　　一 . 前言
　　今天对 Spring 进行深度使用的时候 , 想仿照 AOP 去实现对应的代理 , 但是却触发了 BeanNotOfRequiredTypeException 异常 , 原因是因为 Spring 会进行类的校验
　　于是突然产生了好奇 , 决定研究一下 , AOP 是通过什么方式避开这个校验过程二 . 前置知识AOP 通过 AopProxy 进行代理SpringBoot 1.5 默认使用 JDK Proxy , SpringBoot 2.0 基于自动装配(AopAutoConfiguration)的配置 , 默认使用 CGlib
　　JDK Proxy 和 CGLib 的区别
　　老生常谈的问题 , 问了完整性(凑字数) , 还是简单列一下 :JDK Proxy : 利用拦截器(拦截器必须实现InvocationHanlder)加上反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。CGLIB动态代理:利用ASM开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
　　PS : 通过 proxy-target-class 可以进行配置三 . 原理探索
　　常规方式是 CGLIB , 所以主流程还是通过这种方式分析 , 有了前置知识的补充 , 实现猜测是由于 CGLIB 的特性 , 实际上被校验出来.源头 :autowired 导入得时候会校验注入的类是否正确3.1 拦截的入口Step 1 : AbstractAutowireCapableBeanFactory # populateBeanStep 2 : AutowiredAnnotationBeanPostProcessor # postProcessPropertiesStep 3 : InjectionMetadata # injectStep 4 : AutowiredAnnotationBeanPostProcessor # injectStep 5 : DefaultListableBeanFactory # doResolveDependencypublic Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,       @Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {        //............ 以下是主要逻辑         if (autowiredBeanNames != null) {          autowiredBeanNames.add(autowiredBeanName);       }              // 获取 Autowired 的实际对象或者代理对象       if (instanceCandidate instanceof Class) {          instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);       }              // 判断该对象是否为null       Object result = instanceCandidate;       if (result instanceof NullBean) {          if (isRequired(descriptor)) {             raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);          }          result = null;       }              // 核心拦截逻辑       if (!ClassUtils.isAssignableValue(type, result)) {          throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());       }       return result;    } } 3.2 拦截的判断public static boolean isAssignable(Class<?> lhsType, Class<?> rhsType) {          // 类型判断     if (lhsType.isAssignableFrom(rhsType)) {         return true;     } else {         Class resolvedWrapper;                  // 基本类型特殊处理         if (lhsType.isPrimitive()) {             resolvedWrapper = (Class)primitiveWrapperTypeMap.get(rhsType);             return lhsType == resolvedWrapper;         } else {             resolvedWrapper = (Class)primitiveTypeToWrapperMap.get(rhsType);             return resolvedWrapper != null && lhsType.isAssignableFrom(resolvedWrapper);         }     } } 3.3 AOP 的使用
　　看到了拦截的入口 , 那就得看看 AOP 中是如何通过 PostProcessor 进行处理的了 , 首先看一下 PostProcessor 链表
　　Step 1 : 当对象 A 中字段是 @Autowired 注入的 AOP 代理类时
　　此时我们可以发现 , 在 DefaultListableBeanFactory # doResolveDependency 环节会去获取该代理类的对象 , 拿到的对象如下图所示 :// doResolveDependency 中获取对象环节 if (instanceCandidate instanceof Class) {     // 此时拿到的对象就是一个 cglib 代理类    instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
　　Step 2 : 判断类的关系入口// doResolveDependency 中判断类的关系 -> true if (!ClassUtils.isAssignableValue(type, result)) {    throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass()); }  // result.getClass() - name=com.gang.aop.demo.service.StartService$EnhancerBySpringCGLIB$d673b902
　　Step 3 : 判断类的关系逻辑C- ClassUtils public static boolean isAssignable(Class<?> lhsType, Class<?> rhsType) {        // 核心语句 , native 方法 -> public native boolean isAssignableFrom(Class<?> cls);    if (lhsType.isAssignableFrom(rhsType)) {       return true;    }    //......... }  // 这里简单做了一个继承类 , ChildService extends ChildService : ------> ChildService By ParentService :false <------- : ------> ParentService By ChildService:true <-------
　　由此可见 cglib 创建的对象满足该条件 : 相同 , 或者是超类或者超接口
　　这里回过头看之前的问题 , 就很简单了 :// 问题原因 :  我通过实现 postProcessor 去做了一个代理  public class AopProxyImpl extends Sourceable {     private Sourceable source; }    // 修改后 :  public class AopProxyImpl extends Source {     private Sourceable source; }  // 通过继承即可解决 BeanNotOfRequiredTypeException ,弄懂了就没什么难度了 //       四 . 深入原理
　　那么继续回顾下 CGLIB 的创建过程 , 实际上在编译的结果上是可以很直观的看到代理的对象的 :
　　关于 CGLIB 的基础 , 可以看看菜鸟的文档 CGLIB(Code Generation Library) 介绍与原理 , 写的很详细4.1 CGLIB 的创建过程
　　FastClass 的作用
　　FastClass 就是给每个方法编号，通过编号找到方法，这样可以避免频繁使用反射导致效率比较低
　　CGLIB 会生成2个 fastClass :xxxx$FastClassByCGLIB$xxxx :为生成的代理类中的每个方法建立了索引xxxx$EnhancerByCGLIB$xxxx$FastClassByCGLIB$xxxx : 为我们被代理类的所有方法包含其父类的方法建立了索引
　　原因 : cglib代理基于继承实现，父类中非public、final的方法无法被继承，所以需要一个父类的fastclass来调用代理不到的方法
　　FastClass 中有2个主要的方法 :// 代理方法 public Object invoke(final int n, final Object o, final Object[] array) throws InvocationTargetException {     final CglibService cglibService = (CglibService)o;     switch (n) {         case 0: {             // 代理对应的业务方法             cglibService.run();             return null;         }         case 1: {             // 代理 equeals 方法             return new Boolean(cglibService.equals(array[0]));         }         case 2: {             // 代理 toString 方法             return cglibService.toString();         }         case 3: {             // 代理 hashCode 方法              return new Integer(cglibService.hashCode());         }     }     throw new IllegalArgumentException(＂Cannot find matching method/constructor＂); }           // 实例化对象  public Object newInstance(final int n, final Object[] array) throws InvocationTargetException {     switch (n) {         case 0: {             // 此处总结通过 new 进行了实例化             return new CglibService();         }     }     throw new IllegalArgumentException(＂Cannot find matching method/constructor＂); }
　　enchance 对象
　　之前了解到 , cglib 通过重写字节码生成主类达到代理的目的 , 这里来看一下 , 原方法被改写成什么样了final void CGLIB$run$0() {     super.run(); }      public final void run() {     MethodInterceptor cglib$CALLBACK_2;     MethodInterceptor cglib$CALLBACK_0;     if ((cglib$CALLBACK_0 = (cglib$CALLBACK_2 = this.CGLIB$CALLBACK_0)) == null) {         CGLIB$BIND_CALLBACKS(this);         cglib$CALLBACK_2 = (cglib$CALLBACK_0 = this.CGLIB$CALLBACK_0);     }     if (cglib$CALLBACK_0 != null) {         // 调用拦截器对象         cglib$CALLBACK_2.intercept((Object)this, CglibService$EnhancerByCGLIB$7aba7860.CGLIB$run$0$Method, CglibService$EnhancerByCGLIB$7aba7860.CGLIB$emptyArgs, CglibService$EnhancerByCGLIB$7aba7860.CGLIB$run$0$Proxy);         return;     }     // 没有拦截器对象 , 则直接调用     super.run(); }   // 实际被调用的拦截器 public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {          // 这里会调用关联类     // 最终通过 super.run 调用     Object result = proxy.invokeSuper(obj, args);           return result; }
　　此处也可以看到映射关系
　　总结