SpringBoot中@Autowired生效方式詳解

更新時間：2022年06月17日 10:19:38 作者：alonwang

@Autowired注解可以用在類屬性，構(gòu)造函數(shù)，setter方法和函數(shù)參數(shù)上，該注解可以準確地控制bean在何處如何自動裝配的過程。在默認情況下，該注解是類型驅(qū)動的注入

前言

@Component
public class SimpleBean3 {
    @Autowired
    private SimpleBean simpleBean;
}

@Autowired修飾的字段會被容器自動注入.那么Spring Boot中使如何實現(xiàn)這一功能呢? AutowiredAnnotationBeanPostProcessor!

BeanPostProcessor implementation that autowires annotated fields, setter methods, and arbitrary config methods. Such members to be injected are detected through annotations: by default, Spring's @Autowired and @Value annotations.
Also supports JSR-330's @Inject annotation, if available, as a direct alternative to Spring's own @Autowired.

AutowiredAnnotationBeanPostProcessor(以下簡稱AutowiredProcessor)間接實現(xiàn)了InstantiationAwareBeanPostProcessor接口.通過postProcessProperties(...)完成@Autowired的注入,本文將按照下圖流程梳理AutowiredProcessor的生效邏輯.

SpringBoot-autowired.png

正文

注冊AutowiredProcessor的BeanDefinition

SpringApplication#createApplicationContext默認會創(chuàng)建 AnnotationConfigApplicationContext,而AnnotationConfigApplicationContext又會創(chuàng)建AnnotatedBeanDefinitionReader

    public AnnotationConfigApplicationContext() {
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

AnnotatedBeanDefinitionReader構(gòu)造時會調(diào)用AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry),將AutowiredProcessor的BeanDefinition注冊到容器

    public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
            BeanDefinitionRegistry registry, @Nullable Object source) {
        //忽略部分代碼...
        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));
        }
        //忽略部分代碼...
        return beanDefs;
    }

實例化AutowiredProcessor

在AbstractApplicationContext的refresh階段,會注冊并實例化所有的BeanPostProcessor

public void refresh() throws BeansException, IllegalStateException {
            //...忽略部分代碼
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);
                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);
                // ########### 這里注冊所有的BeanPostProcessor ##########  
                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);
                // Initialize message source for this context.
                initMessageSource();
                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();
                // Initialize other special beans in specific context subclasses.
                onRefresh();
                // Check for listener beans and register them.
                registerListeners();
                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);
                // Last step: publish corresponding event.
                finishRefresh()
            //...忽略部分代碼
    }

實際的注冊邏輯交給了PostProcessorRegistrationDelegate

    protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
    }

在PostProcessorRegistrationDelegate中,獲取到所有的BeanPostProcessor(基于BeanDefinition),并將其分為幾種類型,并按照不同的優(yōu)先級進行處理化,這塊不是這篇文章的重點,我們只需要知道在這里AutowiredProcessor被注冊就可以了.

創(chuàng)建bean時進行注入

以SimpleBean3的注入為例, 它是單例的,在AbstractApplicationContext.refresh()的finishBeanFactoryInitialization(beanFactory)時創(chuàng)建.

    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        //...忽略部分代碼
        // Instantiate all remaining (non-lazy-init) singletons.
        beanFactory.preInstantiateSingletons();
    }

調(diào)用到了BeanFactory.preInstantiateSingletons(),走到getBean()邏輯

public void preInstantiateSingletons() throws BeansException {
        //...忽略部分代碼
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof FactoryBean) {
                        final FactoryBean<?> factory = (FactoryBean<?>) bean;
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                            ((SmartFactoryBean<?>) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean<?>) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else {
                    getBean(beanName);
                }
            }
        }
        //...忽略部分代碼
    }

經(jīng)過一連串的輾轉(zhuǎn),最終調(diào)用到AbstractAutowireCapableBeanFactory#populateBean

附上調(diào)用鏈路

image.png

在populateBean中,會將所有的BeanPostProcessor應用在這個bean上,包括AutowiredProcessor

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        //...忽略部分代碼
        PropertyDescriptor[] filteredPds = null;
        if (hasInstAwareBpps) {
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
          //###### 調(diào)用到postProcessProperties #####
                    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;
                }
            }
        }
    //...忽略部分代碼
    }

AutowiredProcessor的postProcessProperties()會進行注入操作,這需要找到注入的元數(shù)據(jù)(InjectionMetadata)

public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {     
        //### 找到AutowringMetadata #####
        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;
    }

findAutowiringMetadata()又調(diào)用到buildAutowiringMetadata(),生成代表可注入元素的InjectMetadata

private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
        List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
        Class<?> targetClass = clazz;
        do {
            final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
            ReflectionUtils.doWithLocalFields(targetClass, field -> {
        //###### 找到帶有可注入注解的字段
                AnnotationAttributes 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));
                }
            });
            //...忽略部分代碼
    }

findAutowiredAnnotation()根據(jù)AutowiredProcessor的實例字段autowiredAnnotationTypes,去查看是否匹配,這個字段是在AutowiredProcessor創(chuàng)建時初始化,可以看到支持@Autowired,@Value,@Inject三種類型的注入標識.最終據(jù)此完成注入

public AutowiredAnnotationBeanPostProcessor() {
        this.autowiredAnnotationTypes.add(Autowired.class);
        this.autowiredAnnotationTypes.add(Value.class);
        try {
            this.autowiredAnnotationTypes.add((Class&lt;? extends Annotation&gt;)
                    ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
            logger.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
        }
        catch (ClassNotFoundException ex) {
            // JSR-330 API not available - simply skip.
        }
    }

后記

最后再來梳理一下整個流程.

首先是AutowiredPorcessor的BeanDefinition的注冊

=> 創(chuàng)建ApplicationContext

? => 創(chuàng)建AnnotatedBeanDefinitionReader

? => 注冊BeanDefinition registerAnnotationConfigProcessors

然后是AutowiredProcessor注冊為bean

=> registerBeanPostProcessors

最后是注入

? => 獲取bean getBean()

? => 創(chuàng)建bean doCreateBean()

? =>生成bean populateBean()

? => 應用AutowiredProcessor ibp.postProcessProperties()

? => 找到可注入的字段 buildAutowiringMetadata

? => 注入 metadata.inject

至此,@Autowired生效邏輯梳理完成

到此這篇關(guān)于SpringBoot中@Autowired生效方式詳解的文章就介紹到這了,更多相關(guān)SpringBoot @Autowired內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: