Spring 源码解析

文章15 |   阅读 8463 |   点赞0

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

Spring 源码解析九：默认的注解处理器

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

在 Spring 源码解析五：Bean 的配置、定义、注册 中，有一些默认的注解处理器还未解析

1. ConfigurationClassPostProcessor

ConfigurationClassPostProcessor
的主要功能是处理@Configuration类

  1. public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
  2.         PriorityOrdered, ResourceLoaderAware, ApplicationStartupAware, BeanClassLoaderAware, EnvironmentAware {
  3.     // 后置处理registry
  4.     @Override
  5.     public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
  6.         // ... 代码省略
  8.         // 处理配置类bean定义
  9.         processConfigBeanDefinitions(registry);
  10.     }
  12.     // 后置处理registry
  13.     @Override
  14.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  15.         // ... 代码省略
  17.         // 处理配置类bean定义
  18.         processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
  20.         // 使用ConfigurationClassEnhancer对@Configuration的class进行cglib增强
  21.         enhanceConfigurationClasses(beanFactory);
  23.         // ... 代码省略
  24.     }
  25. }
  1. public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
  2.         PriorityOrdered, ResourceLoaderAware, ApplicationStartupAware, BeanClassLoaderAware, EnvironmentAware {
  3.     // 处理配置类bean定义
  4.     public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
  5.         // 配置类集合
  6.         List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
  7.         // 所有bean的名字
  8.         String[] candidateNames = registry.getBeanDefinitionNames();
  10.         // 遍历
  11.         for (String beanName : candidateNames) {
  12.             // 获取bean定义
  13.             BeanDefinition beanDef = registry.getBeanDefinition(beanName);
  15.             // ... 代码省略
  17.             // 如果是@Configuration标记的类，加入集合
  18.             if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
  19.                 configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
  20.             }
  21.         }
  23.         // 没有@Configuration标记的类，返回
  24.         if (configCandidates.isEmpty()) {
  25.             return;
  26.         }
  28.         // ... 代码省略
  30.         // 获取 @Configuration 类解析器
  31.         ConfigurationClassParser parser = new ConfigurationClassParser(
  32.                 this.metadataReaderFactory, this.problemReporter, this.environment,
  33.                 this.resourceLoader, this.componentScanBeanNameGenerator, registry);
  35.         // 待解析集合
  36.         Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
  37.         // 已解析集合
  38.         Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
  39.         do {
  40.             // ... 代码省略
  42.             // 解析配置类
  43.             parser.parse(candidates);
  44.             // 验证配置类
  45.             parser.validate();
  47.             // 获取所有的配置类，包括以前注册的
  48.             Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
  49.             // 移除已解析的
  50.             configClasses.removeAll(alreadyParsed);
  52.             if (this.reader == null) {
  53.                 // 使用ConfigurationClassBeanDefinitionReader创建配置类bean定义读取器
  54.                 this.reader = new ConfigurationClassBeanDefinitionReader(
  55.                         registry, this.sourceExtractor, this.resourceLoader, this.environment,
  56.                         this.importBeanNameGenerator, parser.getImportRegistry());
  57.             }
  58.             // 读取bean定义
  59.             this.reader.loadBeanDefinitions(configClasses);
  60.             // 添加到已解析
  61.             alreadyParsed.addAll(configClasses);
  63.             // ... 代码省略
  64.         }
  65.         while (!candidates.isEmpty());
  67.         // ... 代码省略
  68.     }
  69. }

对@Configuration类的处理核心是 ConfigurationClassParser
实现的

  1. class ConfigurationClassParser {
  2.     public void parse(Set<BeanDefinitionHolder> configCandidates) {
  3.         for (BeanDefinitionHolder holder : configCandidates) {
  4.             BeanDefinition bd = holder.getBeanDefinition();
  5.             try {
  6.                 // AnnotatedBeanDefinition处理
  7.                 if (bd instanceof AnnotatedBeanDefinition) {
  8.                     parse1(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
  9.                 }
  10.                 // AbstractBeanDefinition+beanClass处理
  11.                 else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
  12.                     parse2(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
  13.                 }
  14.                 // 默认处理
  15.                 else {
  16.                     parse3(bd.getBeanClassName(), holder.getBeanName());
  17.                 }
  18.             }
  19.             catch (BeanDefinitionStoreException ex) {
  20.                 // ... 代码省略
  21.             }
  22.             // ... 代码省略
  23.         }
  25.         // ... 代码省略
  26.     }
  28.     protected final void parse1(AnnotationMetadata metadata, String beanName) throws IOException {
  29.         processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
  30.     }
  32.     protected final void parse2(Class<?> clazz, String beanName) throws IOException {
  33.         processConfigurationClass(new ConfigurationClass(clazz, beanName), DEFAULT_EXCLUSION_FILTER);
  34.     }
  36.     protected final void parse3(@Nullable String className, String beanName) throws IOException {
  37.         MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);
  38.         processConfigurationClass(new ConfigurationClass(reader, beanName), DEFAULT_EXCLUSION_FILTER);
  39.     }
  40. }
  1. class ConfigurationClassParser {
  2.     protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
  3.         // ... 代码省略
  5.         // 包裹成SourceClass
  6.         SourceClass sourceClass = asSourceClass(configClass, filter);
  7.         // 遍历处理配置类，及其父类
  8.         do {
  9.             sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
  10.         }
  11.         while (sourceClass != null);
  13.         // ... 代码省略
  14.     }
  16.     // 处理配置类
  17.     protected final SourceClass doProcessConfigurationClass(
  18.             ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
  19.             throws IOException {
  21.         // 处理@Component注解
  22.         if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
  23.             // 遍历处理内部类（非静态内部类）
  24.             processMemberClasses(configClass, sourceClass, filter);
  25.         }
  27.         // 处理@PropertySource注解，装载属性都bean中
  28.         for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
  29.                 sourceClass.getMetadata(), PropertySources.class,
  30.                 org.springframework.context.annotation.PropertySource.class)) {
  31.             // 装载属性都bean中
  32.             processPropertySource(propertySource);
  33.         }
  35.         // 处理@ComponentScan注解，扫描指定的包
  36.         Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
  37.                 sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
  38.         if (!componentScans.isEmpty() &&
  39.                 !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
  40.             // 遍历扫描
  41.             for (AnnotationAttributes componentScan : componentScans) {
  42.                 // 扫描到的bean定义
  43.                 Set<BeanDefinitionHolder> scannedBeanDefinitions =
  44.                         this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
  45.                 // 遍历bean定义
  46.                 for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
  47.                     BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
  48.                     // 如果也标记有@Configuration，继续解析
  49.                     if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
  50.                         parse(bdCand.getBeanClassName(), holder.getBeanName());
  51.                     }
  52.                 }
  53.             }
  54.         }
  56.         // 处理@Import注解
  57.         processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
  59.         // 处理@ImportResource注解
  60.         AnnotationAttributes importResource =
  61.                 AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
  62.         if (importResource != null) {
  63.             // ... 代码省略
  64.         }
  66.         // 处理类中标记为@Bean的方法
  67.         Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
  68.         for (MethodMetadata methodMetadata : beanMethods) {
  69.             configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
  70.         }
  72.         // 如果类是接口，注入默认的方法
  73.         processInterfaces(configClass, sourceClass);
  75.         // 如果有父类，返回父类，继续遍历
  76.         if (sourceClass.getMetadata().hasSuperClass()) {
  77.             // ... 代码省略
  78.         }
  80.         // 没有父类，结束遍历
  81.         return null;
  82.     }
  83. }

2. AutowiredAnnotationBeanPostProcessor

ConfigurationClassPostProcessor
的主要功能是处理 bean 的自动装配

  1. public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor,
  2.         MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
  3.     // 默认处理@Autowired、@Value、@Inject三个注解
  4.     public AutowiredAnnotationBeanPostProcessor() {
  5.         this.autowiredAnnotationTypes.add(Autowired.class);
  6.         this.autowiredAnnotationTypes.add(Value.class);
  7.         try {
  8.             this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
  9.                     ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
  10.         }
  11.         catch (ClassNotFoundException ex) {
  12.             // ... 代码省略
  13.         }
  14.     }
  16.     // 处理属性注入
  17.     @Override
  18.     public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
  19.         // 查找需要注入的元信息
  20.         InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
  21.         try {
  22.             // 注入
  23.             metadata.inject(bean, beanName, pvs);
  24.         }
  25.         catch (BeanCreationException ex) {
  26.             // ... 代码省略
  27.         }
  29.         return pvs;
  30.     }
  32.     // 查找需要注入的元信息
  33.     private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
  34.         // 加锁的方式取出
  35.         InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
  36.         if (InjectionMetadata.needsRefresh(metadata, clazz)) {
  37.             synchronized (this.injectionMetadataCache) {
  38.                 metadata = this.injectionMetadataCache.get(cacheKey);
  39.                 if (InjectionMetadata.needsRefresh(metadata, clazz)) {
  40.                     if (metadata != null) {
  41.                         metadata.clear(pvs);
  42.                     }
  43.                     // 构建元信息
  44.                     metadata = buildAutowiringMetadata(clazz);
  45.                     this.injectionMetadataCache.put(cacheKey, metadata);
  46.                 }
  47.             }
  48.         }
  49.         return metadata;
  50.     }
  51. }
  1. public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor,
  2.         MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
  3.     // 构建元信息
  4.     private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
  5.         // ... 代码省略
  7.         // 注入元素集合
  8.         List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
  9.         Class<?> targetClass = clazz;
  11.         do {
  12.             //  当前元素集合
  13.             final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
  14.             // 遍历本地属性
  15.             ReflectionUtils.doWithLocalFields(targetClass, field -> {
  16.                 // 获取@Autowired、@Value、@Inject注解
  17.                 MergedAnnotation<?> ann = findAutowiredAnnotation(field);
  18.                 if (ann != null) {
  19.                     if (Modifier.isStatic(field.getModifiers())) {
  20.                         // 静态属性不能注入
  21.                         return;
  22.                     }
  23.                     // required 配置
  24.                     boolean required = determineRequiredStatus(ann);
  25.                     // 加入属性元素
  26.                     currElements.add(new AutowiredFieldElement(field, required));
  27.                 }
  28.             });
  30.             // 遍历本地方法
  31.             ReflectionUtils.doWithLocalMethods(targetClass, method -> {
  32.                 Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
  34.                 // ... 代码省略
  36.                 // 获取@Autowired、@Value、@Inject注解
  37.                 MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
  38.                 if (ann != null) {
  39.                     if (Modifier.isStatic(method.getModifiers())) {
  40.                         // 静态方法不能注入
  41.                         return;
  42.                     }
  44.                     // required 配置
  45.                     boolean required = determineRequiredStatus(ann);
  46.                     PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
  47.                     // 加入方法元素
  48.                     currElements.add(new AutowiredMethodElement(method, required, pd));
  49.                 }
  50.             });
  52.             // 添加进注入元素集合
  53.             elements.addAll(0, currElements);
  54.             // 遍历父类
  55.             targetClass = targetClass.getSuperclass();
  56.         }
  57.         while (targetClass != null && targetClass != Object.class);
  59.         return InjectionMetadata.forElements(elements, clazz);
  60.     }
  61. }

属性的注入是 AutowiredFieldElement.inject 完成的，方法参数的注入是 AutowiredMethodElement.inject 完成的

  1. private class AutowiredFieldElement extends InjectionMetadata.InjectedElement {
  2.     @Override
  3.     protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
  4.         Field field = (Field) this.member;
  5.         Object value;
  6.         if (this.cached) {
  7.             // 先从缓存中获取bean，其次从registry获取bean
  8.             value = resolvedCachedArgument(beanName, this.cachedFieldValue);
  9.         }
  10.         else {
  11.             // 实例化一个DependencyDescriptor对象
  12.             DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
  14.             // ... 代码省略
  16.             try {
  17.                 // 从registry获取bean
  18.                 value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
  19.             }
  20.             catch (BeansException ex) {
  21.                 // ... 代码省略
  22.             }
  23.             synchronized (this) {
  24.                 // ... 代码省略
  26.                 // 把autowiredBeanNames注册为beanName的依赖
  27.                 registerDependentBeans(beanName, autowiredBeanNames);
  29.                 // ... 代码省略
  30.             }
  31.         }
  32.         // 把bean注入到属性中
  33.         if (value != null) {
  34.             ReflectionUtils.makeAccessible(field);
  35.             field.set(bean, value);
  36.         }
  37.     }
  38. }
  1. private class AutowiredMethodElement extends InjectionMetadata.InjectedElement {
  2.     @Override
  3.     protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
  4.         // ... 代码省略
  6.         Method method = (Method) this.member;
  7.         Object[] arguments;
  8.         if (this.cached) {
  9.             // 先从缓存中获取参数bean集合，其次从registry获取参数bean集合
  10.             arguments = resolveCachedArguments(beanName);
  11.         }
  12.         else {
  13.             // 参数个数
  14.             int argumentCount = method.getParameterCount();
  15.             // 参数集合
  16.             arguments = new Object[argumentCount];
  18.             // ... 代码省略
  20.             for (int i = 0; i < arguments.length; i++) {
  21.                 // 参数对象
  22.                 MethodParameter methodParam = new MethodParameter(method, i);
  24.                 // ... 代码省略
  26.                 try {
  27.                     // 获取参数注入的bean
  28.                     Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);
  30.                     // ... 代码省略
  32.                     arguments[i] = arg;
  33.                 }
  34.                 catch (BeansException ex) {
  35.                     // ... 代码省略
  36.                 }
  37.             }
  39.             // ... 代码省略
  40.         }
  41.         // 把bean注入到参数中
  42.         if (arguments != null) {
  43.             try {
  44.                 ReflectionUtils.makeAccessible(method);
  45.                 method.invoke(bean, arguments);
  46.             }
  47.             catch (InvocationTargetException ex) {
  48.                 // ... 代码省略
  49.             }
  50.         }
  51.     }
  52. }

3. CommonAnnotationBeanPostProcessor

CommonAnnotationBeanPostProcessor
的主要功能是处理通用 java 注解javax.annotation.*

  1. public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
  2.         implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
  3.     // 处理属性注入
  4.     @Override
  5.     public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
  6.         // 查找需要注入的元信息
  7.         InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
  8.         try {
  9.             // 注入
  10.             metadata.inject(bean, beanName, pvs);
  11.         }
  12.         catch (Throwable ex) {
  13.             // ... 代码省略
  14.         }
  15.         return pvs;
  16.     }
  18.     // 查找需要注入的元信息
  19.     private InjectionMetadata findResourceMetadata(String beanName, final Class<?> clazz, @Nullable PropertyValues pvs) {
  20.         // 加锁的方式取出
  21.         InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
  22.         if (InjectionMetadata.needsRefresh(metadata, clazz)) {
  23.             synchronized (this.injectionMetadataCache) {
  24.                 metadata = this.injectionMetadataCache.get(cacheKey);
  25.                 if (InjectionMetadata.needsRefresh(metadata, clazz)) {
  26.                     if (metadata != null) {
  27.                         metadata.clear(pvs);
  28.                     }
  29.                     // 构建元信息
  30.                     metadata = buildResourceMetadata(clazz);
  31.                     this.injectionMetadataCache.put(cacheKey, metadata);
  32.                 }
  33.             }
  34.         }
  35.         return metadata;
  36.     }
  37. }
  1. public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
  2.         implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
  3.     // 构建元信息
  4.     private InjectionMetadata buildResourceMetadata(final Class<?> clazz) {
  5.         // ... 代码省略
  7.         // 注入元素集合
  8.         List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
  9.         Class<?> targetClass = clazz;
  11.         do {
  12.             //  当前元素集合
  13.             final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
  14.             // 遍历本地属性
  15.             ReflectionUtils.doWithLocalFields(targetClass, field -> {
  16.                 // @WebServiceRef 注解
  17.                 if (webServiceRefClass != null && field.isAnnotationPresent(webServiceRefClass)) {
  18.                     if (Modifier.isStatic(field.getModifiers())) {
  19.                         // 静态属性不能注入
  20.                     }
  21.                     currElements.add(new WebServiceRefElement(field, field, null));
  22.                 }
  23.                 // @EJB 注解
  24.                 else if (ejbClass != null && field.isAnnotationPresent(ejbClass)) {
  25.                     if (Modifier.isStatic(field.getModifiers())) {
  26.                         // 静态属性不能注入
  27.                     }
  28.                     currElements.add(new EjbRefElement(field, field, null));
  29.                 }
  30.                 // @Resource 注解
  31.                 else if (field.isAnnotationPresent(Resource.class)) {
  32.                     if (Modifier.isStatic(field.getModifiers())) {
  33.                         // 静态属性不能注入
  34.                     }
  35.                     if (!this.ignoredResourceTypes.contains(field.getType().getName())) {
  36.                         currElements.add(new ResourceElement(field, field, null));
  37.                     }
  38.                 }
  39.             });
  41.             // 遍历本地方法
  42.             ReflectionUtils.doWithLocalMethods(targetClass, method -> {
  43.                 Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
  45.                 // ... 代码省略
  47.                 // @WebServiceRef 注解
  48.                 if (webServiceRefClass != null && bridgedMethod.isAnnotationPresent(webServiceRefClass)) {
  49.                     if (Modifier.isStatic(method.getModifiers())) {
  50.                         // 静态方法不能注入
  51.                     }
  52.                     PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
  53.                     currElements.add(new WebServiceRefElement(method, bridgedMethod, pd));
  54.                 }
  55.                 // @EJB 注解
  56.                 else if (ejbClass != null && bridgedMethod.isAnnotationPresent(ejbClass)) {
  57.                     if (Modifier.isStatic(method.getModifiers())) {
  58.                         // 静态方法不能注入
  59.                     }
  60.                     PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
  61.                     currElements.add(new EjbRefElement(method, bridgedMethod, pd));
  62.                 }
  63.                 // @Resource 注解
  64.                 else if (bridgedMethod.isAnnotationPresent(Resource.class)) {
  65.                     if (Modifier.isStatic(method.getModifiers())) {
  66.                         // 静态方法不能注入
  67.                     }
  68.                     if (!this.ignoredResourceTypes.contains(paramTypes[0].getName())) {
  69.                         PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
  70.                         currElements.add(new ResourceElement(method, bridgedMethod, pd));
  71.                     }
  72.                 }
  73.             });
  75.             // 添加进注入元素集合
  76.             elements.addAll(0, currElements);
  77.             // 遍历父类
  78.             targetClass = targetClass.getSuperclass();
  79.         }
  80.         while (targetClass != null && targetClass != Object.class);
  82.         return InjectionMetadata.forElements(elements, clazz);
  83.     }
  84. }

4. PersistenceAnnotationBeanPostProcessor

PersistenceAnnotationBeanPostProcessor
的主要功能是处理持久化 java 注解javax.persistence.*

  1. public class PersistenceAnnotationBeanPostProcessor
  2.         implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor,
  3.         MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware, Serializable {
  4.     // 处理属性注入
  5.     @Override
  6.     public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
  7.         // 查找需要注入的元信息
  8.         InjectionMetadata metadata = findPersistenceMetadata(beanName, bean.getClass(), pvs);
  9.         try {
  10.             // 注入
  11.             metadata.inject(bean, beanName, pvs);
  12.         }
  13.         catch (Throwable ex) {
  14.             // ... 代码省略
  15.         }
  16.         return pvs;
  17.     }
  19.     // 查找需要注入的元信息
  20.     private InjectionMetadata findPersistenceMetadata(String beanName, final Class<?> clazz, @Nullable PropertyValues pvs) {
  21.         // 加锁的方式取出
  22.         InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
  23.         if (InjectionMetadata.needsRefresh(metadata, clazz)) {
  24.             synchronized (this.injectionMetadataCache) {
  25.                 metadata = this.injectionMetadataCache.get(cacheKey);
  26.                 if (InjectionMetadata.needsRefresh(metadata, clazz)) {
  27.                     if (metadata != null) {
  28.                         metadata.clear(pvs);
  29.                     }
  30.                     // 构建元信息
  31.                     this.injectionMetadataCache.put(cacheKey, metadata);
  32.                 }
  33.             }
  34.         }
  35.         return metadata;
  36.     }
  37. }
  1. public class PersistenceAnnotationBeanPostProcessor
  2.         implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor,
  3.         MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware, Serializable {
  4.     // 构建元信息
  5.     private InjectionMetadata buildPersistenceMetadata(final Class<?> clazz) {
  6.         // ... 代码省略
  8.         // 注入元素集合
  9.         List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
  10.         Class<?> targetClass = clazz;
  12.         do {
  13.             //  当前元素集合
  14.             final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
  15.             // 遍历本地属性
  16.             ReflectionUtils.doWithLocalFields(targetClass, field -> {
  17.                 // 有 @PersistenceContext、@PersistenceUnit 注解
  18.                 if (field.isAnnotationPresent(PersistenceContext.class) ||
  19.                         field.isAnnotationPresent(PersistenceUnit.class)) {
  20.                     if (Modifier.isStatic(field.getModifiers())) {
  21.                         // 静态属性不能注入
  22.                     }
  23.                     currElements.add(new PersistenceElement(field, field, null));
  24.                 }
  25.             });
  27.             // 遍历本地方法
  28.             ReflectionUtils.doWithLocalMethods(targetClass, method -> {
  29.                 Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
  31.                 // ... 代码省略
  33.                 // 有 @PersistenceContext、@PersistenceUnit 注解
  34.                 if ((bridgedMethod.isAnnotationPresent(PersistenceContext.class) ||
  35.                         bridgedMethod.isAnnotationPresent(PersistenceUnit.class)) &&
  36.                         method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
  37.                     if (Modifier.isStatic(method.getModifiers())) {
  38.                         // 静态方法不能注入
  39.                     }
  40.                     PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
  41.                     currElements.add(new PersistenceElement(method, bridgedMethod, pd));
  42.                 }
  43.             });
  45.             // 添加进注入元素集合
  46.             elements.addAll(0, currElements);
  47.             // 遍历父类
  48.             targetClass = targetClass.getSuperclass();
  49.         }
  50.         while (targetClass != null && targetClass != Object.class);
  52.         return InjectionMetadata.forElements(elements, clazz);
  53.     }
  54. }

5. EventListenerMethodProcessor

EventListenerMethodProcessor
的主要功能是处理事件监听@EventListener

  1. public class EventListenerMethodProcessor
  2.         implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor {
  3.     // 单例bean初始化后
  4.     @Override
  5.     public void afterSingletonsInstantiated() {
  6.         ConfigurableListableBeanFactory beanFactory = this.beanFactory;
  8.         // 获取所有的bean
  9.         String[] beanNames = beanFactory.getBeanNamesForType(Object.class);
  10.         for (String beanName : beanNames) {
  11.             Class<?> type = null;
  12.             try {
  13.                 // 获取bean类型
  14.                 type = AutoProxyUtils.determineTargetClass(beanFactory, beanName);
  15.             }
  16.             catch (Throwable ex) {
  17.                 // ... 代码省略
  18.             }
  19.             if (type != null) {
  20.                 // ... 代码省略
  22.                 try {
  23.                     //  处理 bean
  24.                     processBean(beanName, type);
  25.                 }
  26.                 catch (Throwable ex) {
  27.                     // ... 代码省略
  28.                 }
  29.             }
  30.         }
  31.     }
  33.     //  处理 bean
  34.     private void processBean(final String beanName, final Class<?> targetType) {
  35.         // 是以 org.springframework. 开头的类或有 @EventListener 注解
  36.         if (!this.nonAnnotatedClasses.contains(targetType) &&
  37.                 AnnotationUtils.isCandidateClass(targetType, EventListener.class) &&
  38.                 !isSpringContainerClass(targetType)) {
  40.             Map<Method, EventListener> annotatedMethods = null;
  41.             try {
  42.                 // 选择有 @EventListener 注解的方法
  43.                 annotatedMethods = MethodIntrospector.selectMethods(targetType,
  44.                         (MethodIntrospector.MetadataLookup<EventListener>) method ->
  45.                                 AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));
  46.             }
  47.             catch (Throwable ex) {
  48.                 // ... 代码省略
  49.             }
  51.             // 上下文对象
  52.             ConfigurableApplicationContext context = this.applicationContext;
  53.             // 监听器工厂
  54.             List<EventListenerFactory> factories = this.eventListenerFactories;
  56.             // 遍历方法
  57.             for (Method method : annotatedMethods.keySet()) {
  58.                 // 遍历工厂
  59.                 for (EventListenerFactory factory : factories) {
  60.                     // 如果工厂直接解析监听方法
  61.                     if (factory.supportsMethod(method)) {
  62.                         // 包装方法
  63.                         Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
  64.                         // 封装为标准的监听器
  65.                         ApplicationListener<?> applicationListener =
  66.                                 factory.createApplicationListener(beanName, targetType, methodToUse);
  68.                         // ... 代码省略
  70.                         // 添加进上下文
  71.                         context.addApplicationListener(applicationListener);
  72.                         break;
  73.                     }
  74.                 }
  75.             }
  76.         }
  77.     }
  78. }

6. DefaultEventListenerFactory

DefaultEventListenerFactory
的主要功能是封装有@EventListener注解的方法为标准的监听器

  1. public class DefaultEventListenerFactory implements EventListenerFactory, Ordered {
  2.     @Override
  3.     public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {
  4.         return new ApplicationListenerMethodAdapter(beanName, type, method);
  5.     }
  6. }

本质上就是用 ApplicationListenerMethodAdapter

  1. public class ApplicationListenerMethodAdapter implements GenericApplicationListener {
  2.     // 调用监听方法
  3.     @Override
  4.     public void onApplicationEvent(ApplicationEvent event) {
  5.         processEvent(event);
  6.     }
  8.     // 处理事件
  9.     public void processEvent(ApplicationEvent event) {
  10.         // 获取调用方法的参数，如果有payload，获取payload，没有就是event本身
  11.         Object[] args = resolveArguments(event);
  12.         // 如果符合@EventListener的condition设置，则触发
  13.         if (shouldHandle(event, args)) {
  14.             // 调用method.invoke获取结果
  15.             Object result = doInvoke(args);
  16.             if (result != null) {
  17.                 //  以此结果，继续派发其他事件
  18.                 handleResult(result);
  19.             }
  20.         }
  21.     }
  22. }

后续

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

作者：深予之 (@senntyou)

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

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

相关文章

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