本系列全部基于 Spring 5.2.2.BUILD-SNAPSHOT 版本。因为 Spring 整个体系太过于庞大，所以只会进行关键部分的源码解析。

什么是公共注解？公共注解就是常见的Java注解，特别是JSR-250中的注解。例如：@Resource、@PostConstructor、@PreDestroy 等等，本文也就主要分析这三个注解在 Spring 中是如何处理的。

对 @Resource 注解的处理类是 CommonAnnotationBeanPostProcessor，它通过实现 InstantiationAwareBeanPostProcessor 接口，重写 postProcessProperties() 方法实现对标注了 @Resource 注解的字段或方法的自动注入。

InstantiationAwareBeanPostProcessor 接口的详细信息可以查看Spring IoC bean 的创建。

关于 CommonAnnotationBeanPostProcessor 这个后置处理器是怎么加入到 beanFactory 中的，我们在 Spring IoC component-scan 节点详解 一文中介绍过主要是通过 AnnotationConfigUtils#registerAnnotationConfigProcessors() 实现的。

  1. public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {
  2.     
  3.     // 省略其他代码...
  4.     // 注册用于处理@Resource、@PostConstructor、@PostDestroy注解的后置处理器
  5.     if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  6.         RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
  7.         def.setSource(source);
  8.         beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
  9.     }
  10.     
  11.     // 省略其他代码...
  12.     
  13. }
  1. public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
  2.     super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
  3.     // 寻找需要注入的字段或方法，并封装成 InjectionMetadata
  4.     InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
  5.     // 检查元数据中的注解信息
  6.     metadata.checkConfigMembers(beanDefinition);
  7. }

上面代码中的 findAutowiringMetadata() 方法就是利用反射遍历类的所有字段和方法，找到标注了 @Resource 注解的，并缓存进 injectionMetadataCache 中。

注意：静态字段和静态方法会过滤掉。

findAutowiringMetadata() 方法基本和 AutowiredAnnotationBeanPostProcessor 中的一致，只是处理的注解不同而已，可以查查看Spring IoC @Autowired 注解详解一文中该方法的详解。

  1. public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
  2.     // 从injectionMetadataCache缓存中获取需要注入的字段和方法
  3.     InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
  4.     try {
  5.         // 进行注入
  6.         metadata.inject(bean, beanName, pvs);
  7.     }
  8.     catch (Throwable ex) {
  9.         throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
  10.     }
  11.     return pvs;
  12. }
  14. // InjectMetadata.java
  15. public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
  16.     // 获取检查后的元素
  17.     Collection<InjectedElement> checkedElements = this.checkedElements;
  18.     // 如果checkedElements不为空就使用checkedElements，否则使用injectedElements
  19.     Collection<InjectedElement> elementsToIterate =
  20.         (checkedElements != null ? checkedElements : this.injectedElements);
  21.     if (!elementsToIterate.isEmpty()) {
  22.         // 遍历elementsToIterate
  23.         for (InjectedElement element : elementsToIterate) {
  24.             if (logger.isTraceEnabled()) {
  25.                 logger.trace("Processing injected element of bean '" + beanName + "': " + element);
  26.             }
  27.             // 进行元素注入，见下文详解
  28.             element.inject(target, beanName, pvs);
  29.         }
  30.     }
  31. }
  1. protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
  2.     throws Throwable {
  3.     // 如果元素是字段
  4.     if (this.isField) {
  5.         // 强转成Field类型
  6.         Field field = (Field) this.member;
  7.         // 并设置为可访问
  8.         ReflectionUtils.makeAccessible(field);
  9.         // 然后使用反射设置值
  10.         field.set(target, getResourceToInject(target, requestingBeanName));
  11.     }
  12.     else {
  13.         // 检查是否跳过
  14.         if (checkPropertySkipping(pvs)) {
  15.             return;
  16.         }
  17.         try {
  18.             // 强转成Method类型
  19.             Method method = (Method) this.member;
  20.             // 并设置为可访问
  21.             ReflectionUtils.makeAccessible(method);
  22.             // 使用反射调用方法
  23.             method.invoke(target, getResourceToInject(target, requestingBeanName));
  24.         }
  25.         catch (InvocationTargetException ex) {
  26.             throw ex.getTargetException();
  27.         }
  28.     }
  29. }
  1. protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
  2.     return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) : getResource(this, requestingBeanName));
  3. }

上面的 lazyLookup 就是是否在属性或方法上标注了 @Lazy 注解，该注解先暂不讨论，所以调用后面的 getResource() 方法。

  1. protected Object getResource(LookupElement element, @Nullable String requestingBeanName) throws NoSuchBeanDefinitionException {
  2. 	// 省略其它代码...
  3.     return autowireResource(this.resourceFactory, element, requestingBeanName);
  4. }
  6. protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName) throws NoSuchBeanDefinitionException {
  8.     Object resource;
  9.     Set<String> autowiredBeanNames;
  10.     String name = element.name;
  12.     if (factory instanceof AutowireCapableBeanFactory) {
  13.         AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
  14.         DependencyDescriptor descriptor = element.getDependencyDescriptor();
  15.         // 类型匹配(默认为true) && @Resource注解name属性不为空 && 当前beanFactory不包含名称为name的bean
  16.         if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
  17.             autowiredBeanNames = new LinkedHashSet<>();
  18.             // 按类型查找bean
  19.             resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
  20.             if (resource == null) {
  21.                 throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
  22.             }
  23.         }
  24.         else {
  25.             // 按名称查找bean
  26.             resource = beanFactory.resolveBeanByName(name, descriptor);
  27.             autowiredBeanNames = Collections.singleton(name);
  28.         }
  29.     }
  30.     // 省略其它代码...
  32.     return resource;
  33. }

上面 autowireResource() 方法中按类型查找的 resolveDependency() 方法在Spring IoC bean 的创建一文中分析过，按名称查找 bean 的 resolveBeanByName() 方法实际就是调用 getBean() 通过名称和类型去获取 bean。

从上面的代码也可以看出一般情况下 @Resource 注解是按名称注入；而 @Autowired 注解时按类型注入，具体可以查看Spring IoC @Autowired 注解详解。

处理 @PostConstruct 和 @PreDestroy 注解的处理类是 InitDestroyAnnotationBeanPostProcessor，CommonAnnotationBeanPostProcessor 继承与该类，相当于注册 CommonAnnotationBeanPostProcessor 时也注册了 InitDestroyAnnotationBeanPostProcessor。

InitDestroyAnnotationBeanPostProcessor#postProcessMergedBeanDefinition() 方法是通过 CommonAnnotationBeanPostProcessor#postProcessMergedBeanDefinition() 方法调用的，如下：

  1. public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
  2.     // 调用InitDestroyAnnotationBeanPostProcessor的postProcessMergedBeanDefinition()方法
  3.     super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
  4.     // 寻找需要注入的字段或方法，并封装成 InjectionMetadata
  5.     InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
  6.     // 检查元数据中的注解信息
  7.     metadata.checkConfigMembers(beanDefinition);
  8. }
  1. public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
  2.     // 寻找需要标注了@PostConstruct和@PreDestroy注解的方法，并封装进LifecycleMetadata
  3.     LifecycleMetadata metadata = findLifecycleMetadata(beanType);
  4.     // 检查元数据中的注解信息
  5.     metadata.checkConfigMembers(beanDefinition);
  6. }

上面代码中的 findLifecycleMetadata() 方法，就是遍历当前初始化的 bean 包括其父类中所有标注了 @PostConstruct 和 @PreDestroy 注解的方法，并封装成 LifecycleMetadata （该类是 InitDestroyAnnotationBeanPostProcessor 中一个内部类），并放入 lifecycleMetadataCache 缓存中。

这里我们简单看一下 LifecycleMetadata 这个类：

  1. private class LifecycleMetadata {
  3.     // 目标类，也就是当前正在初始化的bean
  4.     private final Class<?> targetClass;
  5. 	// 存放标注了@PostConstruct的方法
  6.     private final Collection<LifecycleElement> initMethods;
  7. 	// 存放标注了@PreDestroy的方法
  8.     private final Collection<LifecycleElement> destroyMethods;
  10. 	// 省略其它代码...
  11. }
  1. public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  2.     // 从lifecycleMetadataCache缓存中获取LifecycleMetadata
  3.     LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
  4.     try {
  5.         // 反射调用所有初始化方法
  6.         metadata.invokeInitMethods(bean, beanName);
  7.     }
  8. 	// 省略异常处理...
  9.     return bean;
  10. }

看到这里我们知道为什么标注了 @PostConstruct 注解的方法比 InitializingBean#afterPropertiesSet() 和自定义初始化方法先调用了；因为其在 bean 的初始化前回调就已经调用了，而剩下的两个是在初始化方法中调用的，详情可以查看Spring IoC bean 的初始化一文。

我们先了解一下 DestructionAwareBeanPostProcessor，它继承自 BeanPostProcessor，如下：

  1. public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {
  3.     /**
  4.      * Bean 销毁前阶段回调
  5.      */
  6.     void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;
  8.     /**
  9.      * bean实例是否要由此方法销毁
  10.      */
  11.     default boolean requiresDestruction(Object bean) {
  12.         return true;
  13.     }
  15. }
  1. public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
  2.     // 从lifecycleMetadataCache缓存中获取LifecycleMetadata
  3.     LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
  4.     try {
  5.         // 反射调用所有销毁方法
  6.         metadata.invokeDestroyMethods(bean, beanName);
  7.     }
  8. 	// 省略异常处理...
  9. }

和上面的 @PostConstruct 注解一样，@PreDestroy 注解标注的方法也比 DisposableBean#destroy() 和自定义销毁方法先调用。

本文主要介绍了 @Resource、@PostConstruct、@PreDestroy 注解 Spring 是如何对其处理的，可以看出 Spring 的注解驱动大多依靠 实现 BeanPostProcessor 及其子类中的 bean 生命周期各个阶段的回调方法来进行实现的。

最后，我模仿 Spring 写了一个精简版，代码会持续更新。地址：https://github.com/leisurexi/tiny-spring。

版权声明：本文为leisurexi原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/leisurexi/p/13269643.html