Spring源码之自动装配

引言

我们使用Spring开发过程中经常会用到Autowired注解注入依赖的bean，这部分也是面试的热点问题之一。今天咱们一起来深入研究下自动注入的背后实现原理。首先上一个例子，如下所示：

@RestController
public class TestController {
    @Autowired
    List<ICheckRuleService> checkRuleService;

    @RequestMapping("/test")
    public void test(){
        checkRuleService.forEach(x->x.valid());
    }
}

从填充Bean开始

Autowired是怎么实现自动注入的呢，今天我们来通过源码分析一下。当Spring创建 TestController Bean时，会调用AbstractBeanFactory#doGetBean(如果对Spring创建Bean流程不熟的读者，可以给我留言，后面考虑是否写个IOC系列)，doGetBean里面会调用doCreateBean()方法去创建Bean，创建Bean之后，会对Bean进行填充

try {
    this.populateBean(beanName, mbd, instanceWrapper);
    exposedObject = this.initializeBean(beanName, exposedObject, mbd);
}

populateBean 里有这样一段代码，看起来是处理Autowired的，分别是autowireByName 和 autowireByType

PropertyValues pvs = mbd.hasPropertyValues() ? mbd.getPropertyValues() : null;
if (mbd.getResolvedAutowireMode() == 1 || mbd.getResolvedAutowireMode() == 2) {
    MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
    if (mbd.getResolvedAutowireMode() == 1) {
       this.autowireByName(beanName, mbd, bw, newPvs);
    }

   if (mbd.getResolvedAutowireMode() == 2) {
       this.autowireByType(beanName, mbd, bw, newPvs);
   }

    pvs = newPvs;
}

我们来验证一下，通过断点调试我们发现并不会进入if里，所以自动注入并不是这里实现的。那这里有什么用呢，先放一放，后面再说。

后置处理器属性填充

那么到底是哪里注入进去的呢？我们继续往下看，在这段代码下方有个BeanPostProcessor的逻辑，通过断点我们发现有个AutowiredAnnotationBeanPostProcessor 的后置处理器，当这个BeanPostProcessor执行完 postProcessPropertyValues方法后，testController的checkRuleService 属性就有了值了，说明属性值注入肯定和 AutowiredAnnotationBeanPostProcessor 有关，我们跟进去看一下

进入AutowiredAnnotationBeanPostProcessor的postProcessPropertyValues 方法里，里面主要有两部分逻辑

首先看到一段 findAutowiringMetadata 的逻辑，根据方法名称知道是获取当前bean的注入元信息
调用 metadata.inject 注入属性

public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
    InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(), pvs);

    try {
        metadata.inject(bean, beanName, pvs);
        return pvs;
    } catch (BeanCreationException var7) {
        throw var7;
    } catch (Throwable var8) {
        throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", var8);
    }
}

我们先来看第一部分：findAutowiringMetadata

我们进入findAutowiringMetadata，看下它的逻辑，先从 injectionMetadataCache 缓存里取，如果取不到值，则调用buildAutowiringMetadata 构建 InjectionMetadata ，构建成功后设置到缓存里。

    private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
        String cacheKey = StringUtils.hasLength(beanName) ? beanName : clazz.getName();
        InjectionMetadata metadata = (InjectionMetadata)this.injectionMetadataCache.get(cacheKey);
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized(this.injectionMetadataCache) {
                metadata = (InjectionMetadata)this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }

                    metadata = this.buildAutowiringMetadata(clazz);
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }

        return metadata;
    }

我们来看下 buildAutowiringMetadata，继续跟进去，源码如下：

里面是通过当前Bean的Class反射获取 Field 和 Method ，然后对 Field 和 Method 分别调 findAutowiredAnnotation 方法获取自动注入的注解，然后根据注解类型是否required构建不同类型的InjectedElement。

AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement：

boolean required = this.determineRequiredStatus(ann);
currElements.add(new AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement(field, required));

AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement：

boolean required = this.determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement(method, required, pd));

补充：通过AutowiredAnnotationBeanPostProcessor 构造函数我们知道，自动注入处理的是被 @Autowired 和 @Value 这两个注解标注的属性(Field)或方法(Method)：

    public AutowiredAnnotationBeanPostProcessor() {

        this.autowiredAnnotationTypes.add(Autowired.class);

        this.autowiredAnnotationTypes.add(Value.class);

    //......

到这里，需要注入的元数据信息就已经构建完成了，接下来就要到注入部分了。来看下 postProcessPropertyValues 的第二部分。

再看第二部分：metadata.inject

前面获取到了需要注入的元数据信息，接下来是元数据 inject 的实现，继续跟进去，里面是一个for循环，循环调用了element的inject方法

if (!((Collection)elementsToIterate).isEmpty()) {
    for(Iterator var6 = ((Collection)elementsToIterate).iterator(); var6.hasNext(); element.inject(target, beanName, pvs)) {
        element = (InjectionMetadata.InjectedElement)var6.next();
        if (logger.isDebugEnabled()) {
            logger.debug("Processing injected element of bean '" + beanName + "': " + element);
        }
    }
}

我们断点调试进去，发现element的真实类型是AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement，而当前element 真实类型是 TestController.checkRuleService 的集合。

我们进入AutowiredFieldElement#inject方法，首先尝试从缓存里拿当前Field的值，肯定拿不到，所以走的是else分支，else分支里从beanFactory里解析当前Field属性值

value = AutowiredAnnotationBeanPostProcessor.this.beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);

继续跟进去，发现其实调用的 doResolveDependency 方法

越来越接近真相了，不要着急，继续跟进去

发现一个类型为Object的 multipleBeans ，结果返回的也是这个Object，我们大胆猜测这个Object就是我们需要注入的List属性，继续跟进去验证一下：

我们看一下 Collection 分支的源码

 else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
            elementType = descriptor.getResolvableType().asCollection().resolveGeneric(new int[0]);
            if (elementType == null) {
                return null;
            } else {
                Map<String, Object> matchingBeans = this.findAutowireCandidates(beanName, elementType, new DefaultListableBeanFactory.MultiElementDescriptor(descriptor));
                if (matchingBeans.isEmpty()) {
                    return null;
                } else {
                    if (autowiredBeanNames != null) {
                        autowiredBeanNames.addAll(matchingBeans.keySet());
                    }

                    TypeConverter converter = typeConverter != null ? typeConverter : this.getTypeConverter();
                    Object result = converter.convertIfNecessary(matchingBeans.values(), type);
                    if (this.getDependencyComparator() != null && result instanceof List) {
                        ((List)result).sort(this.adaptDependencyComparator(matchingBeans));
                    }

                    return result;
                }
            }
        }

里面是调用了 findAutowireCandidates 来获取Bean，findAutowireCandidates 内部会获取到依赖的BeanNames，然后根据beanName 循环调用beanFactory#getBean 获取需要注入的bean

this.findAutowireCandidates(beanName,elementType,new DefaultListableBeanFactory.MultiElementDescriptor(descriptor))

beanFactory#getBean方法，最终会调用 AbstractBeanFactory#doGetBean，获取到需要装配进去的属性bean。

    public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) throws BeansException {
        return beanFactory.getBean(beanName);
    }

当所有的循环执行完毕，就获取到了 multipleBeans ，验证了前面的猜测。真是太不容易，赶紧设置缓存 😄

最终通过field.set 将获取到的List属性值value设置到当前bean里，代码如下：

if (value != null) {
    ReflectionUtils.makeAccessible(field);
    field.set(bean, value);
}

执行field的set方法后，再来看checkRuleService属性就有值了

如果是Method注入，对应的就是通过反射调用 method.invoke 将属性设置到方法参数里，大致流程差不多。到此，Autowired 装配流程也就结束了。

前面在讲到 populateBean 的时候，有个根据 autowireMode 判断是否执行属性注入，当时获取的autowireMode==0，那么什么时候autowireMode 会有值并且会根据autowireByName 和 autowireByType来装配呢？

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw)

其实也很好理解，通过源码我们知道，这里的 mbd 是一个 RootBeanDefinition ，也就是说这里的 mbd.getResolvedAutowireMode()获取的值是通过Bean定义或者通过PostProcessor拿到BeanDefinition，然后设置了AutowireMode属性才会有值。当我们查看这里的autowireByType源码（AbstractAutowireCapableBeanFactory#autowireByType）可以发现，其实autowireByType也是会调用resolveDependency，继续跟进去，发现其实调用的 doResolveDependency 方法，而AutowiredAnnotationBeanPostProcessor 也是通过这个方法实现的自动注入，后面的流程就都一样了。

最后总结一下

1、bean创建完成后，会调用 populateBean() 填充Bean，在populateBean()方法里会获取所有的BeanPostProcessor，并循环执行 BeanPostProcessor#postProcessPropertyValues() 设置属性

2、其中有个AutowiredAnnotationBeanPostProcessor，这个处理器里会根据当前Bean的Class，通过反射获取 Field 和 Method ，分别获取 Field 和 Method 上的自动注入的注解(@Autowired 和 @Value)，构建注入元数据InjectionMetadata

3、调用注入元数据InjectionMetadata的 inject() 方法，装配属性(有两种：AutowiredFieldElement 和AutowiredMethodElement)，会调用this.beanFactory.resolveDependency(desc,beanName,autowiredBeanNames, typeConverter) 解析依赖的属性值

4、resolveDependency 最终会调用到 resolveMultipleBeans ，而 resolveMultipleBeans 会根据当前注入属性的类型分别按 Array、Collection、Map 走不同的分支，在分支里调用 findAutowireCandidates 获取注入bean的实例，最终回调到 AbstractBeanFactory#doGetBean

5、获取到所有需要注入的属性 bean 实例后，通过反射设置到对应的属性或方法里去，就完成了自动注入全流程了

posted @ 2020-06-07 21:14 Mr.yang.localhost 阅读(743) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Mr.yang.localhost