Spring源码解析之@Autowired注解实现原理

Spring @Autowired注解实现原理

前言

IOC是Spring的核心功能之一，在日常开发中，我们经常用到@Autowired注解来完成自动装配工作，但它的原理是怎样的呢？本文将带着读者分析Autowired注解实现原理，让我们带着如下问题阅读本文。

1. Autowired注解是如何实现自动装配的？
2. 若容器中存在多个B类的实例，当B为自动注入的属性时，spring是如何选择的？
3. Spring自动装配有哪几种？和Autowired有何关联？
   
   

一、Demo演示

---

首先，搭建demo工程来演示@Autowired注解的使用，demo工程见DIExample

依赖注入bean定义

Tree2类中，自动装配leaf属性。

public class Tree2 {
    @Autowired
    private Leaf leaf;

    public void sayHello() {
        System.out.println("get a leaf: " + leaf.getName());
    }

    public Tree2() {
        System.out.println("construct the tree.");
    }

    public void init() {
        System.out.println("init the tree.");
    }

    public void destroy() {
        System.out.println("destroy the tree.");
    }
}

创建Bean的配置类

@Configuration
public class DIConfig {
    @Bean
    public Leaf leaf() {
        Leaf leaf = new Leaf();
        leaf.setName("green");
        return leaf;
    }

    @Bean
    public Tree2 tree2() {
        return new Tree2();
    }
}

容器启动类

public class DIExample {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(DIConfig.class);
        Tree2 tree2 = context.getBean("tree2", Tree2.class);
        tree2.sayHello();
    }
}

输出结果

construct Leaf
00:23:49.292 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'tree2'
construct the tree.
get a leaf: green

Process finished with exit code 0

二、Autowired实现原理(AutowiredAnnotationBeanPostProcessor)

---

Spring有一个内置处理器AutowiredAnnotationBeanPostProcessor，在Spring Bean的生命周期中，当Bean实例化之后，执行属性设置时，会通过该处理器，完成Autowired的自动注入。

2.1 AutowiredAnnotationBeanPostProcessor 类结构图

AutowiredAnnotationBeanPostProcessor处理器实现了多个扩展接口，主要接口如下：

• BeanFactoryAware：通过BeanFactory获取容器中的Bean
• BeanPostProcessor：在Bean初始化前后执行Bean后置处理器
• InstantiationAwareBeanPostProcessor：在 Bean 实例化前后和Bean设置属性值时执行的后置处理器
• MergedBeanDefinitionPostProcessor：合并Bean的定义信息

2.2 内置处理器何时创建

AutowiredAnnotationBeanPostProcessor是何时创建注册入容器？

  在分析AutowiredAnnotationBeanPostProcessor原理之前，我们需要知道它是如何被创建并加入Spring容器中，一个后置处理器需要被加入容器中才能作用到其他Bean，如下图为Spring执行流程

  上图所示1-1流程为容器创建BeanDefinition扫描器，并调用AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);为容器注册几个内置处理器，其中就包括AutowiredAnnotationBeanPostProcessor。相关代码如下

    public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
            BeanDefinitionRegistry registry, @Nullable Object source) {

        // ......省略代码.....
        Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
        // 注册AutowiredAnnotationBeanPostProcessor,这个bean的后置处理器用来处理@Autowired的注入
        if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // 注册CommonAnnotationBeanPostProcessor，用来处理如@Resource等符合JSR-250规范的注解
        if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
        }
        //..........其他内置处理器注册............
        return beanDefs;
    }

2.3 何时调用处理器

AutowiredAnnotationBeanPostProcessor是何时被调用的呢？

  Spring在创建Bean的过程中，最终会调用AbstractAutowireCapableBeanFactory.doCreateBean()方法创建实例，在doCreateBean()方法中调用populateBean()方法为bean填充属性，并完成autowired自动装配工作。参加如下流程图

• 实例化
    整个实例化主要是3-11-6-4步骤，其中3-11-6-4-2步骤属性注入AbstractAutowireCapableBeanFactory.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) {
                    // 获取AutowiredAnnotationBeanPostProcessor做属性注入处理，自动装配autowired属性
                    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;
                }
            }
        }
        // 省略代码...
        }
    }

  执行处理器的postProcessProperties()方法，并调用findAutowiringMetadata()方法，通过反射获取需要注入的属性和值，最后调用metadata.inject()注入属性。对反射这块感兴趣的同学可以再深入查看源码，本文就不详细阐述了。

public PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
	// 解析出bean中带有@Autowired注解、@Inject和@Value注解的属性和方法
	// 至于如何解析的，findAutowiringMetadata()方法比较复杂，这里就不展开了，Spring中提供了很多对注解等元数据信息读取的方法，进行了大量的封装。
	// 如果不是自己亲自参与开发Spring的话，很难摸透它封装的那些数据结构。
	InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
	try {
		// 自动装配，实现依赖注入
		metadata.inject(bean, beanName, pvs);
	}
	catch (BeanCreationException ex) {
		throw ex;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
	}
	return pvs;
}

总结

本文通过源码主要分析了@Autowired注解的实现原理是通过AutowiredAnnotationBeanPostProcessor这个后置处理器来实现的，然后针对@Autowired注入过程中放射原理进行了分析。

References

1. https://juejin.cn/post/6844903957135884295#heading-7
2. https://my.oschina.net/xiaolyuh/blog/3113215