Spring 源码解析

文章15 |   阅读 8467 |   点赞0

来源：https://github.com/senntyou/blogs

Spring 源码解析四：Bean 的构造装载、属性值解析、注解扫描

x33g5p2x  于2022-02-11 发布在 Spring  
字(23.9k)|赞(0)|评价(0)|浏览(614)

上一篇主要介绍了 Bean 的注册、解析、实例化，但留下一些点待解析：

  • ConstructorResolver.autowireConstructor 如何进行构造装载并实例化的
  • CglibSubclassingInstantiationStrategy.instantiate 如何动态实例化 bean 的
  • BeanDefinitionValueResolver.resolveValueIfNecessary 如何解析属性值的
  • MergedAnnotations.from 如何扫描注解的

这一节，就来解析这几个点

1. ConstructorResolver.autowireConstructor

ConstructorResolver
的主要功能是在构造时载入依赖的 bean 和用 factory-method 实例化 bean，这里只讲第一个：在构造时载入依赖的 bean ConstructorResolver.autowireConstructor

  1. class ConstructorResolver {
  2.     public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
  3.             @Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
  4.         // 实例化一个封装对象
  5.         BeanWrapperImpl bw = new BeanWrapperImpl();
  7.         // 需要使用的构造方法
  8.         Constructor<?> constructorToUse = null;
  9.         // 需要使用的构造参数
  10.         Object[] argsToUse = null;
  12.         // 如果指定了参数，就使用指定的参数
  13.         if (explicitArgs != null) {
  14.             argsToUse = explicitArgs;
  15.         }
  16.         else {
  17.             Object[] argsToResolve = null;
  18.             // 并发处理
  19.             synchronized (mbd.constructorArgumentLock) {
  20.                 // 获取定义中已解析的构造方法
  21.                 constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
  22.                 if (constructorToUse != null && mbd.constructorArgumentsResolved) {
  23.                     // 获取定义中已解析的参数，首先是resolvedConstructorArguments，其次是preparedConstructorArguments
  24.                     argsToUse = mbd.resolvedConstructorArguments;
  25.                     if (argsToUse == null) {
  26.                         argsToResolve = mbd.preparedConstructorArguments;
  27.                     }
  28.                 }
  29.             }
  30.             if (argsToResolve != null) {
  31.                 // 把参数解析成实际要用的数据，如bean装配、属性载入
  32.                 argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
  33.             }
  34.         }
  36.         // 如果没有指定的构造方法或参数
  37.         if (constructorToUse == null || argsToUse == null) {
  38.             Constructor<?>[] candidates = chosenCtors;
  39.             if (candidates == null) {
  40.                 // 如果传入的chosenCtors是空，则获取beanClass的构造方法
  41.                 Class<?> beanClass = mbd.getBeanClass();
  42.                 try {
  43.                     candidates = (mbd.isNonPublicAccessAllowed() ?
  44.                             beanClass.getDeclaredConstructors() : beanClass.getConstructors());
  45.                 }
  46.                 catch (Throwable ex) {
  47.                     // ... 代码省略
  48.                 }
  49.             }
  51.             // 如果只有一个构造方法，并且没有指定explicitArgs和constructorArgumentValues
  52.             if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
  53.                 Constructor<?> uniqueCandidate = candidates[0];
  54.                 // 如果构造方法没有参数需要装配，直接实例化返回
  55.                 if (uniqueCandidate.getParameterCount() == 0) {
  56.                     synchronized (mbd.constructorArgumentLock) {
  57.                         mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
  58.                         mbd.constructorArgumentsResolved = true;
  59.                         mbd.resolvedConstructorArguments = EMPTY_ARGS;
  60.                     }
  61.                     // 实例化bean
  62.                     bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
  63.                     return bw;
  64.                 }
  65.             }
  67.             // 有构造方法，且构造模式为AUTOWIRE_CONSTRUCTOR，则需要自动装配bean
  68.             boolean autowiring = (chosenCtors != null ||
  69.                     mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
  70.             ConstructorArgumentValues resolvedValues = null;
  72.             // ... 代码省略
  75.             // 选择一个参数数量、参数类型、参数顺序与需要实例化参数对象最接近的一个构造方法
  76.             // 这里的计算比较复杂，有兴趣的朋友可以自行探索一下
  77.             for (Constructor<?> candidate : candidates) {
  78.                 // ... 代码省略
  79.             }
  81.             // ... 代码省略
  82.         }
  84.         // 实例化bean
  85.         bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
  86.         return bw;
  87.     }
  89.     // 实例化bean，默认使用CglibSubclassingInstantiationStrategy.instantiate来实例化
  90.     private Object instantiate(
  91.             String beanName, RootBeanDefinition mbd, Constructor<?> constructorToUse, Object[] argsToUse) {
  93.         try {
  94.             InstantiationStrategy strategy = this.beanFactory.getInstantiationStrategy();
  95.             if (System.getSecurityManager() != null) {
  96.                 return AccessController.doPrivileged((PrivilegedAction<Object>) () ->
  97.                         strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse),
  98.                         this.beanFactory.getAccessControlContext());
  99.             }
  100.             else {
  101.                 return strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
  102.             }
  103.         }
  104.         catch (Throwable ex) {
  105.             // ... 代码省略
  106.         }
  107.     }
  108. }

最终的实例化仍然需要CglibSubclassingInstantiationStrategy.instantiate来实现

2. CglibSubclassingInstantiationStrategy.instantiate

CglibSubclassingInstantiationStrategy
的主要功能是使用 cglib 的方式实例化 bean

  1. public class CglibSubclassingInstantiationStrategy extends SimpleInstantiationStrategy {}

我们先来看看 SimpleInstantiationStrategy

  1. public class SimpleInstantiationStrategy implements InstantiationStrategy {
  2.     // 用于调用factory-method
  3.     private static final ThreadLocal<Method> currentlyInvokedFactoryMethod = new ThreadLocal<>();
  5.     @Override
  6.     public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
  7.         // 没有方法需要重载
  8.         if (!bd.hasMethodOverrides()) {
  9.             Constructor<?> constructorToUse;
  10.             synchronized (bd.constructorArgumentLock) {
  11.                 // 首先获取已解析的构造方法
  12.                 constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
  13.                 if (constructorToUse == null) {
  14.                     // 没有已解析的构造方法，则用beanClass获取
  15.                     final Class<?> clazz = bd.getBeanClass();
  16.                     // 接口不能实例化
  17.                     if (clazz.isInterface()) {
  18.                         throw new BeanInstantiationException(clazz, "Specified class is an interface");
  19.                     }
  20.                     try {
  21.                         if (System.getSecurityManager() != null) {
  22.                             constructorToUse = AccessController.doPrivileged(
  23.                                     (PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
  24.                         }
  25.                         else {
  26.                             // 通过Class获取构造方法
  27.                             constructorToUse = clazz.getDeclaredConstructor();
  28.                         }
  29.                         // 设为已解析的构造方法
  30.                         bd.resolvedConstructorOrFactoryMethod = constructorToUse;
  31.                     }
  32.                     catch (Throwable ex) {
  33.                         // 如果Class没有构造方法，报错
  34.                     }
  35.                 }
  36.             }
  37.             // 调用Constructor..newInstance实例化
  38.             return BeanUtils.instantiateClass(constructorToUse);
  39.         }
  40.         else {
  41.             // 有方法需要重载，则需要用cglib生成一个新的子类
  42.             return instantiateWithMethodInjection(bd, beanName, owner);
  43.         }
  44.     }
  46.     // 方法注入实例化，留给子类实现
  47.     protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
  48.         throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
  49.     }
  51.     @Override
  52.     public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
  53.             final Constructor<?> ctor, Object... args) {
  54.         // 没有方法需要重载
  55.         if (!bd.hasMethodOverrides()) {
  56.             // ... 代码省略
  58.             // 调用Constructor.newInstance实例化
  59.             return BeanUtils.instantiateClass(ctor, args);
  60.         }
  61.         else {
  62.             // 有方法需要重载，则需要用cglib生成一个新的子类
  63.             return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
  64.         }
  65.     }
  67.     // 方法注入实例化，留给子类实现
  68.     protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName,
  69.             BeanFactory owner, @Nullable Constructor<?> ctor, Object... args) {
  70.         throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
  71.     }
  73.     // 通过factory-method初始化
  74.     @Override
  75.     public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
  76.             @Nullable Object factoryBean, final Method factoryMethod, Object... args) {
  78.         try {
  79.             // ... 代码省略
  81.             // 直接调用Method.invoke实例化
  82.             Object result = factoryMethod.invoke(factoryBean, args);
  83.             // 如果为null，实例化一个NullBean
  84.             if (result == null) {
  85.                 result = new NullBean();
  86.             }
  87.             return result;
  88.         }
  89.         catch (IllegalArgumentException ex) {
  90.             // ... 代码省略
  91.         }
  92.         catch (IllegalAccessException ex) {
  93.             // ... 代码省略
  94.         }
  95.         catch (InvocationTargetException ex) {
  96.             // ... 代码省略
  97.         }
  98.     }
  99. }

我们先来看看 CglibSubclassingInstantiationStrategy

  1. public class CglibSubclassingInstantiationStrategy extends SimpleInstantiationStrategy {
  2.     @Override
  3.     protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
  4.         return instantiateWithMethodInjection(bd, beanName, owner, null);
  5.     }
  7.     @Override
  8.     protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
  9.             @Nullable Constructor<?> ctor, Object... args) {
  10.         // 生成一个CglibSubclassCreator来实例化
  11.         return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
  12.     }
  13. }

CglibSubclassCreator是CglibSubclassingInstantiationStrategy的内部类

  1. private static class CglibSubclassCreator {
  2.     // 实例化一个构造函数
  3.     public Object instantiate(@Nullable Constructor<?> ctor, Object... args) {
  4.         // 使用cglib Enhancer创建一个加强子类
  5.         Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
  6.         Object instance;
  7.         if (ctor == null) {
  8.             // 如果没有指定构造函数，调用Constructor.newInstance实例化
  9.             instance = BeanUtils.instantiateClass(subclass);
  10.         }
  11.         else {
  12.             try {
  13.                 // 获取与ctor参数匹配的子类构造函数，再调用Constructor.newInstance实例化
  14.                 Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
  15.                 instance = enhancedSubclassConstructor.newInstance(args);
  16.             }
  17.             catch (Exception ex) {
  18.                 // ... 代码省略
  19.             }
  20.         }
  22.         // ... 代码省略
  24.         return instance;
  25.     }
  27.     // 使用cglib Enhancer创建一个加强子类
  28.     private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) {
  29.         Enhancer enhancer = new Enhancer();
  30.         enhancer.setSuperclass(beanDefinition.getBeanClass());
  31.         enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
  32.         if (this.owner instanceof ConfigurableBeanFactory) {
  33.             ClassLoader cl = ((ConfigurableBeanFactory) this.owner).getBeanClassLoader();
  34.             enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl));
  35.         }
  36.         enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
  37.         enhancer.setCallbackTypes(CALLBACK_TYPES);
  38.         return enhancer.createClass();
  39.     }
  40. }

3. BeanDefinitionValueResolver.resolveValueIfNecessary

BeanDefinitionValueResolver
的主要功能是将配置的属性值装载到 bean 中

  1. class BeanDefinitionValueResolver {
  2.     public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
  3.         // 在运行时对其他bean的引用
  4.         if (value instanceof RuntimeBeanReference) {
  5.             RuntimeBeanReference ref = (RuntimeBeanReference) value;
  6.             // 解析引用bean
  7.             return resolveReference(argName, ref);
  8.         }
  9.         // 在运行时对其他bean name的引用
  10.         else if (value instanceof RuntimeBeanNameReference) {
  11.             String refName = ((RuntimeBeanNameReference) value).getBeanName();
  12.             // 使用doEvaluate解析bean名字，执行SpEL表达式
  13.             refName = String.valueOf(doEvaluate(refName));
  14.             if (!this.beanFactory.containsBean(refName)) {
  15.                 // 没注册过bean name，报错
  16.             }
  17.             return refName;
  18.         }
  19.         // 包含别名的bean定义
  20.         else if (value instanceof BeanDefinitionHolder) {
  21.             BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
  22.             // 解析内部bean
  23.             return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
  24.         }
  25.         // bean定义
  26.         else if (value instanceof BeanDefinition) {
  27.             BeanDefinition bd = (BeanDefinition) value;
  28.             // 内部bean名字
  29.             String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR +
  30.                     ObjectUtils.getIdentityHexString(bd);
  31.             // 解析内部bean
  32.             return resolveInnerBean(argName, innerBeanName, bd);
  33.         }
  34.         // 注入依赖描述(类、方法、属性)
  35.         else if (value instanceof DependencyDescriptor) {
  36.             Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
  37.             // 解析依赖
  38.             Object result = this.beanFactory.resolveDependency(
  39.                     (DependencyDescriptor) value, this.beanName, autowiredBeanNames, this.typeConverter);
  40.             for (String autowiredBeanName : autowiredBeanNames) {
  41.                 if (this.beanFactory.containsBean(autowiredBeanName)) {
  42.                     // 注册依赖
  43.                     this.beanFactory.registerDependentBean(autowiredBeanName, this.beanName);
  44.                 }
  45.             }
  46.             return result;
  47.         }
  49.         // ... 代码省略
  51.         // 是字符类型的值
  52.         else if (value instanceof TypedStringValue) {
  53.             TypedStringValue typedStringValue = (TypedStringValue) value;
  54.             // 使用evaluate解析bean名字，执行SpEL表达式
  55.             Object valueObject = evaluate(typedStringValue);
  56.             try {
  57.                 // 解析类型
  58.                 Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
  59.                 // 如果有类型，把valueObject转换成这个类型
  60.                 if (resolvedTargetType != null) {
  61.                     return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
  62.                 }
  63.                 // 没有指定类型，则返回原本的
  64.                 else {
  65.                     return valueObject;
  66.                 }
  67.             }
  68.             catch (Throwable ex) {
  69.                 // ... 代码省略
  70.             }
  71.         }
  72.         // 如果是NullBean，返回null
  73.         else if (value instanceof NullBean) {
  74.             return null;
  75.         }
  76.         // 默认当成SpEL表达式解析了
  77.         else {
  78.             return evaluate(value);
  79.         }
  80.     }
  81. }

BeanDefinitionValueResolver.resolveReference
解析引用 bean

  1. class BeanDefinitionValueResolver {
  2.     private Object resolveReference(Object argName, RuntimeBeanReference ref) {
  3.         try {
  4.             Object bean;
  5.             // 获取bean类型
  6.             Class<?> beanType = ref.getBeanType();
  7.             if (ref.isToParent()) {
  8.                 // 指明从父BeanFactory中获取
  9.                 BeanFactory parent = this.beanFactory.getParentBeanFactory();
  11.                 if (beanType != null) {
  12.                     // 如果有beanType，直接通过类型获取bean
  13.                     bean = parent.getBean(beanType);
  14.                 }
  15.                 else {
  16.                     // 使用doEvaluate解析bean名字，执行SpEL表达式，然后根据名字查找bean
  17.                     bean = parent.getBean(String.valueOf(doEvaluate(ref.getBeanName())));
  18.                 }
  19.             }
  20.             else {
  21.                 String resolvedName;
  22.                 if (beanType != null) {
  23.                     // 如果有beanType，直接通过类型获取bean
  24.                     NamedBeanHolder<?> namedBean = this.beanFactory.resolveNamedBean(beanType);
  25.                     bean = namedBean.getBeanInstance();
  26.                     resolvedName = namedBean.getBeanName();
  27.                 }
  28.                 else {
  29.                     // 使用doEvaluate解析bean名字，执行SpEL表达式，然后根据名字查找bean
  30.                     resolvedName = String.valueOf(doEvaluate(ref.getBeanName()));
  31.                     bean = this.beanFactory.getBean(resolvedName);
  32.                 }
  33.                 // 注册依赖
  34.                 this.beanFactory.registerDependentBean(resolvedName, this.beanName);
  35.             }
  36.             // 如果是NullBean，返回null
  37.             if (bean instanceof NullBean) {
  38.                 bean = null;
  39.             }
  40.             return bean;
  41.         }
  42.         catch (BeansException ex) {
  43.             // ... 代码省略
  44.         }
  45.     }
  47.     // 调用beanFactory来解析bean名字，执行SpEL表达式
  48.     private Object doEvaluate(String value) {
  49.         return this.beanFactory.evaluateBeanDefinitionString(value, this.beanDefinition);
  50.     }
  51. }

BeanDefinitionValueResolver.resolveInnerBean
解析内部 bean

  1. class BeanDefinitionValueResolver {
  2.     private Object resolveInnerBean(Object argName, String innerBeanName, BeanDefinition innerBd) {
  3.         RootBeanDefinition mbd = null;
  4.         try {
  5.             // 获取合并父bean定义的bean定义
  6.             mbd = this.beanFactory.getMergedBeanDefinition(innerBeanName, innerBd, this.beanDefinition);
  8.             String actualInnerBeanName = innerBeanName;
  9.             if (mbd.isSingleton()) {
  10.                 // 如果同类型的bean被实例化多次，则使用后缀#1,#2...来命名之后的bean
  11.                 actualInnerBeanName = adaptInnerBeanName(innerBeanName);
  12.             }
  13.             // 把新生成的名字注册到beanFactory
  14.             this.beanFactory.registerContainedBean(actualInnerBeanName, this.beanName);
  15.             // 获取依赖
  16.             String[] dependsOn = mbd.getDependsOn();
  17.             if (dependsOn != null) {
  18.                 for (String dependsOnBean : dependsOn) {
  19.                     // 注册依赖
  20.                     this.beanFactory.registerDependentBean(dependsOnBean, actualInnerBeanName);
  21.                     // 确保加载
  22.                     this.beanFactory.getBean(dependsOnBean);
  23.                 }
  24.             }
  25.             // 创建bean
  26.             Object innerBean = this.beanFactory.createBean(actualInnerBeanName, mbd, null);
  27.             // 如果bean实例是FactoryBean，则调用factory-method获取真正的bean
  28.             if (innerBean instanceof FactoryBean) {
  29.                 boolean synthetic = mbd.isSynthetic();
  30.                 innerBean = this.beanFactory.getObjectFromFactoryBean(
  31.                         (FactoryBean<?>) innerBean, actualInnerBeanName, !synthetic);
  32.             }
  33.             // 如果是NullBean，返回null
  34.             if (innerBean instanceof NullBean) {
  35.                 innerBean = null;
  36.             }
  37.             return innerBean;
  38.         }
  39.         catch (BeansException ex) {
  40.             // ... 代码省略
  41.         }
  42.     }
  44.     // 如果同类型的bean被实例化多次，则使用后缀#1,#2...来命名之后的bean
  45.     private String adaptInnerBeanName(String innerBeanName) {
  46.         String actualInnerBeanName = innerBeanName;
  47.         int counter = 0;
  48.         String prefix = innerBeanName + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR;
  49.         while (this.beanFactory.isBeanNameInUse(actualInnerBeanName)) {
  50.             counter++;
  51.             actualInnerBeanName = prefix + counter;
  52.         }
  53.         return actualInnerBeanName;
  54.     }
  55. }

4. MergedAnnotations.from

MergedAnnotations.from
的底层实现其实是 TypeMappedAnnotations.from

TypeMappedAnnotations的主要功能就是搜索、操作注解

  1. final class TypeMappedAnnotations implements MergedAnnotations {
  2.     static MergedAnnotations from(AnnotatedElement element, SearchStrategy searchStrategy,
  3.             RepeatableContainers repeatableContainers, AnnotationFilter annotationFilter) {
  4.         // 没有可用的注解，直接返回NONE
  5.         if (AnnotationsScanner.isKnownEmpty(element, searchStrategy)) {
  6.             return NONE;
  7.         }
  8.         return new TypeMappedAnnotations(element, searchStrategy, repeatableContainers, annotationFilter);
  9.     }
  11.     static MergedAnnotations from(@Nullable Object source, Annotation[] annotations,
  12.             RepeatableContainers repeatableContainers, AnnotationFilter annotationFilter) {
  13.         // 没有要查找的注解，直接返回NONE
  14.         if (annotations.length == 0) {
  15.             return NONE;
  16.         }
  17.         return new TypeMappedAnnotations(source, annotations, repeatableContainers, annotationFilter);
  18.     }
  19. }
  1. final class TypeMappedAnnotations implements MergedAnnotations {
  2.     // 检查是否有annotationType
  3.     @Override
  4.     public <A extends Annotation> boolean isPresent(Class<A> annotationType) {
  5.         // 过滤器没通过，返回false
  6.         if (this.annotationFilter.matches(annotationType)) {
  7.             return false;
  8.         }
  9.         // 扫描目标元素(类、方法、属性)
  10.         return Boolean.TRUE.equals(scan(annotationType,
  11.                 IsPresent.get(this.repeatableContainers, this.annotationFilter, false)));
  12.     }
  14.     // 检查是否有annotationType
  15.     @Override
  16.     public boolean isPresent(String annotationType) {
  17.         // 过滤器没通过，返回false
  18.         if (this.annotationFilter.matches(annotationType)) {
  19.             return false;
  20.         }
  21.         // 扫描目标元素(类、方法、属性)
  22.         return Boolean.TRUE.equals(scan(annotationType,
  23.                 IsPresent.get(this.repeatableContainers, this.annotationFilter, false)));
  24.     }
  26.     // 获取目标元素的annotationType注解对象
  27.     @Override
  28.     public <A extends Annotation> MergedAnnotation<A> get(Class<A> annotationType,
  29.             @Nullable Predicate<? super MergedAnnotation<A>> predicate,
  30.             @Nullable MergedAnnotationSelector<A> selector) {
  31.         // 过滤器没通过，返回空
  32.         if (this.annotationFilter.matches(annotationType)) {
  33.             return MergedAnnotation.missing();
  34.         }
  35.         // 扫描目标元素(类、方法、属性)
  36.         MergedAnnotation<A> result = scan(annotationType,
  37.                 new MergedAnnotationFinder<>(annotationType, predicate, selector));
  38.         return (result != null ? result : MergedAnnotation.missing());
  39.     }
  41.     // 获取目标元素的annotationType注解对象
  42.     @Override
  43.     public <A extends Annotation> MergedAnnotation<A> get(String annotationType,
  44.             @Nullable Predicate<? super MergedAnnotation<A>> predicate,
  45.             @Nullable MergedAnnotationSelector<A> selector) {
  46.         // 过滤器没通过，返回空
  47.         if (this.annotationFilter.matches(annotationType)) {
  48.             return MergedAnnotation.missing();
  49.         }
  50.         // 扫描目标元素(类、方法、属性)
  51.         MergedAnnotation<A> result = scan(annotationType,
  52.                 new MergedAnnotationFinder<>(annotationType, predicate, selector));
  53.         return (result != null ? result : MergedAnnotation.missing());
  54.     }
  56.     // 扫描目标元素(类、方法、属性)
  57.     private <C, R> R scan(C criteria, AnnotationsProcessor<C, R> processor) {
  58.         // 如果有传入的注解对象，就不扫描目标元素了
  59.         if (this.annotations != null) {
  60.             R result = processor.doWithAnnotations(criteria, 0, this.source, this.annotations);
  61.             return processor.finish(result);
  62.         }
  63.         // 有目标元素和扫描策略，扫描目标元素
  64.         if (this.element != null && this.searchStrategy != null) {
  65.             return AnnotationsScanner.scan(criteria, this.element, this.searchStrategy, processor);
  66.         }
  67.         return null;
  68.     }
  69. }

TypeMappedAnnotations.scan 的底层实现是 AnnotationsScanner.scan

  1. abstract class AnnotationsScanner {
  2.     // 扫描注解
  3.     static <C, R> R scan(C context, AnnotatedElement source, SearchStrategy searchStrategy,
  4.             AnnotationsProcessor<C, R> processor) {
  5.         // 实际扫描处理
  6.         R result = process(context, source, searchStrategy, processor);
  7.         return processor.finish(result);
  8.     }
  10.     // 实际扫描处理
  11.     private static <C, R> R process(C context, AnnotatedElement source,
  12.             SearchStrategy searchStrategy, AnnotationsProcessor<C, R> processor) {
  13.         // 如果目标元素是类，按类处理
  14.         if (source instanceof Class) {
  15.             return processClass(context, (Class<?>) source, searchStrategy, processor);
  16.         }
  17.         // 如果目标元素是方法，按方法处理
  18.         if (source instanceof Method) {
  19.             return processMethod(context, (Method) source, searchStrategy, processor);
  20.         }
  21.         // 不然按普通处理
  22.         return processElement(context, source, processor);
  23.     }
  24. }

4.1. 按类处理

  1. abstract class AnnotationsScanner {
  2.     private static <C, R> R processClass(C context, Class<?> source,
  3.             SearchStrategy searchStrategy, AnnotationsProcessor<C, R> processor) {
  5.         switch (searchStrategy) {
  6.             // 只搜索自身的注解，按普通处理
  7.             case DIRECT:
  8.                 return processElement(context, source, processor);
  9.             // 搜索自身与标记为@Inherited父类的注解
  10.             case INHERITED_ANNOTATIONS:
  11.                 return processClassInheritedAnnotations(context, source, searchStrategy, processor);
  12.             // 搜索自身与父类的注解
  13.             case SUPERCLASS:
  14.                 return processClassHierarchy(context, source, processor, false, false);
  15.             // 搜索自身、父类、接口的注解
  16.             case TYPE_HIERARCHY:
  17.                 return processClassHierarchy(context, source, processor, true, false);
  18.             // 搜索自身、父类、接口、getEnclosingClass()的注解
  19.             case TYPE_HIERARCHY_AND_ENCLOSING_CLASSES:
  20.                 return processClassHierarchy(context, source, processor, true, true);
  21.         }
  22.         throw new IllegalStateException("Unsupported search strategy " + searchStrategy);
  23.     }
  25.     // 搜索自身与标记为@Inherited父类的注解
  26.     private static <C, R> R processClassInheritedAnnotations(C context, Class<?> source,
  27.             SearchStrategy searchStrategy, AnnotationsProcessor<C, R> processor) {
  28.         try {
  29.             // 如果除了自身以外，没有父类、接口、getEnclosingClass()的注解，按普通处理
  30.             if (isWithoutHierarchy(source, searchStrategy)) {
  31.                 return processElement(context, source, processor);
  32.             }
  33.             Annotation[] relevant = null;
  34.             int remaining = Integer.MAX_VALUE;
  35.             int aggregateIndex = 0;
  36.             Class<?> root = source;
  38.             // source对象还可以继续向父类上溯
  39.             // 非Object，非Ordered，非"java."开头
  40.             while (source != null && source != Object.class && remaining > 0 &&
  41.                     !hasPlainJavaAnnotationsOnly(source)) {
  43.                 // 聚合处理，如果有了，直接返回（默认未实现）
  44.                 R result = processor.doWithAggregate(context, aggregateIndex);
  45.                 if (result != null) {
  46.                     return result;
  47.                 }
  49.                 // 获取所有public的注解
  50.                 Annotation[] declaredAnnotations = getDeclaredAnnotations(source, true);
  52.                 // ... 代码省略
  54.                 // 处理器自定义处理
  55.                 result = processor.doWithAnnotations(context, aggregateIndex, source, declaredAnnotations);
  56.                 // 如果有了，返回
  57.                 if (result != null) {
  58.                     return result;
  59.                 }
  60.                 // 上溯父类，继续扫描
  61.                 source = source.getSuperclass();
  62.                 aggregateIndex++;
  63.             }
  64.         }
  65.         catch (Throwable ex) {
  66.             // ... 代码省略
  67.         }
  68.         return null;
  69.     }
  71.     // 搜索自身、父类、接口、getEnclosingClass()的注解
  72.     private static <C, R> R processClassHierarchy(C context, int[] aggregateIndex, Class<?> source,
  73.             AnnotationsProcessor<C, R> processor, boolean includeInterfaces, boolean includeEnclosing) {
  74.         try {
  75.             // 聚合处理，如果有了，直接返回（默认未实现）
  76.             R result = processor.doWithAggregate(context, aggregateIndex[0]);
  77.             if (result != null) {
  78.                 return result;
  79.             }
  80.             // 如果是Ordered或"java."开头，返回
  81.             if (hasPlainJavaAnnotationsOnly(source)) {
  82.                 return null;
  83.             }
  84.             // 获取所有public的注解
  85.             Annotation[] annotations = getDeclaredAnnotations(source, false);
  86.             // 处理器自定义处理
  87.             result = processor.doWithAnnotations(context, aggregateIndex[0], source, annotations);
  88.             // 如果有了，返回
  89.             if (result != null) {
  90.                 return result;
  91.             }
  92.             aggregateIndex[0]++;
  94.             // 如果包括接口，继续搜索接口的
  95.             if (includeInterfaces) {
  96.                 for (Class<?> interfaceType : source.getInterfaces()) {
  97.                     R interfacesResult = processClassHierarchy(context, aggregateIndex,
  98.                         interfaceType, processor, true, includeEnclosing);
  99.                     if (interfacesResult != null) {
  100.                         return interfacesResult;
  101.                     }
  102.                 }
  103.             }
  105.             // 如果有父类，继续搜索父类的
  106.             Class<?> superclass = source.getSuperclass();
  107.             if (superclass != Object.class && superclass != null) {
  108.                 R superclassResult = processClassHierarchy(context, aggregateIndex,
  109.                     superclass, processor, includeInterfaces, includeEnclosing);
  110.                 if (superclassResult != null) {
  111.                     return superclassResult;
  112.                 }
  113.             }
  115.             // 如果包括getEnclosingClass()，继续搜索getEnclosingClass()的
  116.             if (includeEnclosing) {
  117.                 try {
  118.                     Class<?> enclosingClass = source.getEnclosingClass();
  119.                     if (enclosingClass != null) {
  120.                         R enclosingResult = processClassHierarchy(context, aggregateIndex,
  121.                             enclosingClass, processor, includeInterfaces, true);
  122.                         if (enclosingResult != null) {
  123.                             return enclosingResult;
  124.                         }
  125.                     }
  126.                 }
  127.                 catch (Throwable ex) {
  128.                     // ... 代码省略
  129.                 }
  130.             }
  131.         }
  132.         catch (Throwable ex) {
  133.             // ... 代码省略
  134.         }
  135.         return null;
  136.     }
  137. }

4.2. 按方法处理

  1. abstract class AnnotationsScanner {
  2.     private static <C, R> R processMethod(C context, Method source,
  3.             SearchStrategy searchStrategy, AnnotationsProcessor<C, R> processor) {
  5.         switch (searchStrategy) {
  6.             // 只搜索自身的注解
  7.             case DIRECT:
  8.             // 搜索自身与标记为@Inherited父类的注解
  9.             case INHERITED_ANNOTATIONS:
  10.                 return processMethodInheritedAnnotations(context, source, processor);
  11.             // 搜索自身与父类的注解
  12.             case SUPERCLASS:
  13.                 return processMethodHierarchy(context, new int[] {0}, source.getDeclaringClass(),
  14.                         processor, source, false);
  15.             // 搜索自身、父类、接口的注解
  16.             case TYPE_HIERARCHY:
  17.             // 搜索自身、父类、接口、getEnclosingClass()的注解
  18.             case TYPE_HIERARCHY_AND_ENCLOSING_CLASSES:
  19.                 return processMethodHierarchy(context, new int[] {0}, source.getDeclaringClass(),
  20.                         processor, source, true);
  21.         }
  22.         throw new IllegalStateException("Unsupported search strategy " + searchStrategy);
  23.     }
  25.     // 搜索自身与标记为@Inherited父类的注解
  26.     private static <C, R> R processMethodInheritedAnnotations(C context, Method source,
  27.             AnnotationsProcessor<C, R> processor) {
  29.         try {
  30.             // 聚合处理，如果有了，直接返回（默认未实现）
  31.             // 不然，用processMethodAnnotations处理
  32.             R result = processor.doWithAggregate(context, 0);
  33.             return (result != null ? result :
  34.                 processMethodAnnotations(context, 0, source, processor));
  35.         }
  36.         catch (Throwable ex) {
  37.             // ... 代码省略
  38.         }
  39.         return null;
  40.     }
  42.     // 处理方法的注解
  43.     private static <C, R> R processMethodAnnotations(C context, int aggregateIndex, Method source,
  44.             AnnotationsProcessor<C, R> processor) {
  46.       // 获取所有public的注解
  47.         Annotation[] annotations = getDeclaredAnnotations(source, false);
  48.         // 处理器自定义处理
  49.         R result = processor.doWithAnnotations(context, aggregateIndex, source, annotations);
  50.         // 如果有了，返回
  51.         if (result != null) {
  52.             return result;
  53.         }
  55.         // ... 代码省略，桥接方法的处理
  57.         return null;
  58.     }
  60.     // 搜索自身、父类、接口、getEnclosingClass()的注解
  61.     private static <C, R> R processMethodHierarchy(C context, int[] aggregateIndex,
  62.             Class<?> sourceClass, AnnotationsProcessor<C, R> processor, Method rootMethod,
  63.             boolean includeInterfaces) {
  64.         try {
  65.             // 聚合处理，如果有了，直接返回（默认未实现）
  66.             R result = processor.doWithAggregate(context, aggregateIndex[0]);
  67.             if (result != null) {
  68.                 return result;
  69.             }
  70.             // 如果是Ordered或"java."开头，返回
  71.             if (hasPlainJavaAnnotationsOnly(sourceClass)) {
  72.                 return null;
  73.             }
  75.             boolean calledProcessor = false;
  76.             // 如果rootMethod是sourceClass的，直接处理
  77.             if (sourceClass == rootMethod.getDeclaringClass()) {
  78.                 result = processMethodAnnotations(context, aggregateIndex[0],
  79.                     rootMethod, processor);
  80.                 calledProcessor = true;
  81.                 if (result != null) {
  82.                     return result;
  83.                 }
  84.             }
  85.             else {
  86.                 // 获取sourceClass的public方法
  87.                 for (Method candidateMethod : getBaseTypeMethods(context, sourceClass)) {
  88.                     // 如果方法不是private，并且参数与rootMethod一直，直接处理
  89.                     if (candidateMethod != null && isOverride(rootMethod, candidateMethod)) {
  90.                         result = processMethodAnnotations(context, aggregateIndex[0],
  91.                             candidateMethod, processor);
  92.                         calledProcessor = true;
  93.                         if (result != null) {
  94.                             return result;
  95.                         }
  96.                     }
  97.                 }
  98.             }
  99.             // 如果rootMethod是private，返回null
  100.             if (Modifier.isPrivate(rootMethod.getModifiers())) {
  101.                 return null;
  102.             }
  104.             // 如果包括接口，继续搜索接口的
  105.             if (includeInterfaces) {
  106.                 for (Class<?> interfaceType : sourceClass.getInterfaces()) {
  107.                     R interfacesResult = processMethodHierarchy(context, aggregateIndex,
  108.                         interfaceType, processor, rootMethod, true);
  109.                     if (interfacesResult != null) {
  110.                         return interfacesResult;
  111.                     }
  112.                 }
  113.             }
  115.             // 如果有父类，继续搜索父类的
  116.             Class<?> superclass = sourceClass.getSuperclass();
  117.             if (superclass != Object.class && superclass != null) {
  118.                 R superclassResult = processMethodHierarchy(context, aggregateIndex,
  119.                     superclass, processor, rootMethod, includeInterfaces);
  120.                 if (superclassResult != null) {
  121.                     return superclassResult;
  122.                 }
  123.             }
  124.         }
  125.         catch (Throwable ex) {
  126.             // ... 代码省略
  127.         }
  128.         return null;
  129.     }
  130. }

4.3 按普通处理

  1. abstract class AnnotationsScanner {
  2.     private static <C, R> R processElement(C context, AnnotatedElement source,
  3.             AnnotationsProcessor<C, R> processor) {
  5.         try {
  6.             // 聚合处理，如果有了，直接返回（默认未实现）
  7.             // 不然，调用getDeclaredAnnotations获取注解来处理
  8.             R result = processor.doWithAggregate(context, 0);
  9.             return (result != null ? result : processor.doWithAnnotations(
  10.                 context, 0, source, getDeclaredAnnotations(source, false)));
  11.         }
  12.         catch (Throwable ex) {
  13.             // ... 代码省略
  14.         }
  15.         return null;
  16.     }
  17. }

后续

更多博客，查看 https://github.com/senntyou/blogs

作者：深予之 (@senntyou)

版权声明：自由转载-非商用-非衍生-保持署名（创意共享 3.0 许可证）

内容来源于网络，如有侵权，请联系作者删除！

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com