7

Spring @Autowired 注解自动注入流程是怎么样？

 3 years ago
source link: https://segmentfault.com/a/1190000038251563
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.

面试中碰到面试官问：”Spring 注解是如果工作的？“，当前我一惊，完了这不触及到我的知识误区了吗？，还好我机智，灵机一动回了句：Spring 注解的工作流程倒还没有看到，但是我知道 @Autowired 注解的工作流程，后面不用说了一顿巴拉，面试官都连连点头。

面试中要活用转移话题，要避免回答 ”不知道“，要引导面试官掉入你擅长的技术，然后才有机会教他作人。

@Autowired 相关的类

@Autowired 注解的主要功能就是完成自动注入，使用也非常简单（Spring都安排好了），但是要想知道 @Autowired 注解的内部现实，就需要看一下Spring源码了。接下来一步步的解剖 @Autowired 的实现原理，首先理一下与 @Autowired 注解相关的类，然后一步步的跟踪源码，直到理解 @Autowired 的原理。

AutowiredAnnotationBeanPostProcessor 类

AutowiredAnnotationBeanPostProcessor 是实现 @Autowired 功能的主要类，它有一些方法是会用解析 @Autowired 注解并实现自动注入的功能，下面是它的继承图：

vEzQbyu.png!mobile

从上图可以发现 AutowiredAnnotationBeanPostProcessor 最上层是 BeanPostProcessor 是一个后处理器，当然除了后处理器外中间还有 InstantiationAwareBeanPostProcessor 和 MergedBeanDefinitionPostProcessor ：

InstantiationAwareBeanPostProcessor 接口

postProcessBeforeInstantiation方法

在Bean实例化之前调用，可以返回一个Bean实例，默认返回 null 。 

@Nullabledefault Object postProcessBeforeInstantiation(Class<?> beanClass, String 
beanName) throws BeansException {      return null;}

postProcessAfterInstantiation方法

在Bean创建完成后，设置属性之前调用。

default boolean postProcessAfterInstantiation(Object bean, String 
beanName) throws BeansException {      return true;}

postProcessProperties方法

@Nullable default PropertyValues postProcessProperties(PropertyValues pvs, Object 
bean, String beanName)            throws BeansException {      return null;}

Bean创建完后，设置属性之前调用

先记住 InstantiationAwareBeanPostProcessor 接口，后面会跟踪调用它的地方，就很容易理解了。

MergedBeanDefinitionPostProcessor

MergedBeanDefinitionPostProcessor 也是一个继承 BeanPostProcessor 接口的后处理器，它的主要作用就是可以处理操作 BeanDefinition 对象，由于Bean的实例化是通过 BeanDefinition 的， 通过操作BeanDefinition ，这样可以使Bean的实例化时发生一些变化。

MergedBeanDefinitionPostProcessor 只有两个方法

postProcessMergedBeanDefinition方法

void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, 
Class<?> beanType, String beanName);

Bean的BeanDefinition 被合并后调用此方法。

resetBeanDefinition

default void resetBeanDefinition(String beanName) {}

当一个BeanDefinition被重置后调用 。

AutowireCapableBeanFactory 接口

AutowireCapableBeanFactory 继承自 BeanFactory ，除了提供基础的Bean操作外，从接口的名字就可以推断出的它还有 自动注入 的能力。AutowireCapableBeanFactory 提供四种注入模型：

  • AUTOWIRE_NO： 没有显示的定义注入模型
  • AUTOWIRE_BY_NAME： 通过Bean名称注入
  • AUTOWIRE_BY_TYPE： 通过Bean的类型注入
  • AUTOWIRE_CONSTRUCTOR：通过Bean的构造方法注入

AutowireCapableBeanFactory 接口有不少方法，但大部分都是跟自动注入的相关。@Autowired 的主要功能就是在Bean实例化后，为其设置属性，所以在 AutowireCapableBeanFactory 接口有一个 createBean 方法，用于创建Bean并设置Bean的属性： 

<T> T createBean(Class<T> beanClass) throws BeansException;

createBean 方法，它的调用时机是创建Bean的时候，稍后会说到它的调用时机。

AbstractAutowireCapableBeanFactory

qiyme2Q.png!mobile

AbstractAutowireCapableBeanFactory 继承 AbstractBeanFactory 并实现了 AutowireCapableBeanFactory 接口，所以它也实现了 AutowireCapableBeanFactory 中的 createBean 方法。 

public <T> T createBean(Class<T> beanClass) throws BeansException {     

// Use prototype bean definition, to avoid registering bean as dependent bean.      

RootBeanDefinition bd = new RootBeanDefinition(beanClass);      
bd.setScope(SCOPE_PROTOTYPE);     

bd.allowCaching = ClassUtils.isCacheSafe(beanClass, getBeanClassLoader());      

return (T) createBean(beanClass.getName(), bd, null);}

Bean创建的生命周期

通过了解Bean创建的生命周期，才可以将上面与 @Autowired 相关的类串起来，首先这里不会过多的介绍Bean的创建细节，只关注自动注入相关的代码。

Bean的创建过程

Spring中默认的Bean都是懒加载的，所以一个Bean的创建会从调用 getBean 方法开始，如果不考虑缓存、上层容器的情况，Bean的创建会经过以下方法：

  • getBean：BeanFactory的方法，获取Bean实例
  • doGetBean：获取Bean的实例，获取顺序依次为：单例池、父容器，如果从以上2种途径都没获取到Bean实例就会创建新的
  • createBean：创建 Bean，这里的createBean，跟上面介绍的是一回事
  • doCreateBean：创建Bean实例
  • populateBean：设置Bean属性

以上流程中的 getBean 和 doGetBean 不多作说明了， 重点关注 createBean 前面提到 AbstractAutowireCapableBeanFactory.createBean 方法，所以说你在调用 getBean 方法获取Bean的实例时，如果这个Bean实例还没有被创建，那么 createBean 就会被调用。

通过简单的说明Bean创建的生命周期，就能找到 @Autowired 注解实现的入口，接下来再继续跟踪 createBean 方法。

收集注入元信息

收集注入元信息的步骤的，其实就是调用 AutowiredAnnotationBeanPostProcessor 类方法来实现的。

Bean 创建之前

以下是 createBean 方法，在Bean创建之前调用 postProcessBeforeInstantiation 的地方。为是阅读方便省略了一些代码，大致的流程就是：

  • 首先调用 resolveBeforeInstantiation 方法，执行 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation 方法
  • 如果 postProcessBeforeInstantiation 返回Bean实例那么直接返回这个实例，如果返回nul 继续调用 doCreateBean 
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {
 
   ...

   try {
      // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      if (bean != null) {
         return bean;
      }
   }
   catch (Throwable ex) {
        ...
   }
   
     ...
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    ...
   
   ...
 }
   
 @Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
   Object bean = null;
   if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
      // Make sure bean class is actually resolved at this point.
      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
         Class<?> targetType = determineTargetType(beanName, mbd);
         if (targetType != null) {
            bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
            if (bean != null) {
               bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
            }
         }
      }
      mbd.beforeInstantiationResolved = (bean != null);
   }
   return bean;
}

这里 AutowiredAnnotationBeanPostProcessor 的 postProcessBeforeInstantiation 的方法会被调用，由于AutowiredAnnotationBeanPostProcessor 并没有重写这个方法，所以什么都不做。

操作 BeanDefinition

上面说过 postProcessBeforeInstantiation 方法返回 null 的话会继续执行 doCreateBean 方法： 

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {


   // Allow post-processors to modify the merged bean definition.
   synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
         try {
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
         }
         catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                  "Post-processing of merged bean definition failed", ex);
         }
         mbd.postProcessed = true;
      }
   }

  ...
 populateBean(beanName, mbd, instanceWrapper);
 ...

在 doCreateBean 方法中，会调用调用 applyMergedBeanDefinitionPostProcessors 方法： 

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof MergedBeanDefinitionPostProcessor) {
         MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
         bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
      }
   }

MergedBeanDefinitionPostProcessor 接口上面提到到的，AutowiredAnnotationBeanPostProcessor 实现了这个接口所以直接进入到 AutowiredAnnotationBeanPostProcessor 中的 postProcessMergedBeanDefinition 方法： 

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
   InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
   metadata.checkConfigMembers(beanDefinition);
}

查找注入元数据

接着继续进入到 findAutowiringMetadata ，findAutowiringMetadata 会调用 buildAutowiringMetadata 方法创建注入元数据，然后将元数据缓存到 injectionMetadataCache 属性中： 

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
   // Fall back to class name as cache key, for backwards compatibility with custom callers.
   String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
   // Quick check on the concurrent map first, with minimal locking.
   InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
   if (InjectionMetadata.needsRefresh(metadata, clazz)) {
      synchronized (this.injectionMetadataCache) {
         metadata = this.injectionMetadataCache.get(cacheKey);
         if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            ...
            metadata = buildAutowiringMetadata(clazz);
            this.injectionMetadataCache.put(cacheKey, metadata);
         }
      }
   }
   return metadata;
}

创建注入元数据

仔细查看 buildAutowiringMetadata 方法的实现，它会反射类的方法和属性，同时还会向上查找父类，然后生成 InjectionMetadata 。 

private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
        if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
            return InjectionMetadata.EMPTY;
        }

        List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
        Class<?> targetClass = clazz;

        do {
            final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

            ReflectionUtils.doWithLocalFields(targetClass, field -> {
                MergedAnnotation<?> ann = findAutowiredAnnotation(field);
                if (ann != null) {
                    if (Modifier.isStatic(field.getModifiers())) {
                        if (logger.isInfoEnabled()) {
                            logger.info("Autowired annotation is not supported on static fields: " + field);
                        }
                        return;
                    }
                    boolean required = determineRequiredStatus(ann);
                    currElements.add(new AutowiredFieldElement(field, required));
                }
            });

            ReflectionUtils.doWithLocalMethods(targetClass, method -> {
                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
                if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                    return;
                }
                MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
                if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                    if (Modifier.isStatic(method.getModifiers())) {
                        if (logger.isInfoEnabled()) {
                            logger.info("Autowired annotation is not supported on static methods: " + method);
                        }
                        return;
                    }
                    if (method.getParameterCount() == 0) {
                        if (logger.isInfoEnabled()) {
                            logger.info("Autowired annotation should only be used on methods with parameters: " +
                                    method);
                        }
                    }
                    boolean required = determineRequiredStatus(ann);
                    PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                    currElements.add(new AutowiredMethodElement(method, required, pd));
                }
            });

            elements.addAll(0, currElements);
            targetClass = targetClass.getSuperclass();
        }
        while (targetClass != null && targetClass != Object.class);

        return InjectionMetadata.forElements(elements, clazz);
    }

小结

收集注入元数据过程，首先调用 AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition 方法，然后调用 findAutowiringMetadata 方法查找元数据，如果找到相应类的注入元数据 ，就会调用 buildAutowiringMetadata 方法创建 InjectionMetadata ，最后将新创建的注入元数据保存在 injectionMetadataCache 缓存起来。

设置Bean属性

收信完注入元数据后，Bean的属性还是没有注入的，还需要将执行属性注入。还是在 doCreateBean 方法中，收集完注入元数据后，紧接着会调用 populateBean ： 

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
   
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
   if (pvs == null) {
      pvs = mbd.getPropertyValues();
   }
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof InstantiationAwareBeanPostProcessor) {
         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
         PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
         if (pvsToUse == null) {
            if (filteredPds == null) {
               filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
               return;
            }
         }
         pvs = pvsToUse;
      }
   }
   }
}

可以看到在 populateBean 中会调用 InstantiationAwareBeanPostProcessor.postProcessProperties 方法，由于已经知道 AutowiredAnnotationBeanPostProcessor 是实现 InstantiationAwareBeanPostProcessor 的，所以可以直接查看实现方法： 

@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
   InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
   try {
      metadata.inject(bean, beanName, pvs);
   }
   catch (Throwable ex) {
      throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
   }
   return pvs;
}

postProcessProperties 就很简单的，查找 InjectMetadata，然后调用 InjectMetadata.inject 方法。到这里其实就已经知道 @Autowire 的实现机制了，接下来就是根据 InjectionMetadata 中的信息实现属性注入了。

如果需要深入研究的话，有兴趣的还可以继续往下看。

总结

本文大致讲解了 @Autowire 相关的类与实现的机制，@Autowire 注解的实现主要是理解 AutowiredAnnotationBeanPostProcessor 类，还有收集注入元数据、设置注入属性的调用时机。

通过查看 AutowiredAnnotationBeanPostProcessor 类源码，相信你也可以自定义注入功能。

本人知识水平有限，如有错误，谢谢大家指正。

公众号后台回复 arch028 获取资料：

q2iUvmE.png!mobile


report

Recommend

About Joyk


Aggregate valuable and interesting links.
Joyk means Joy of geeK