Spring @Autowired注解自动装配过程

最新推荐文章于 2023-03-18 21:15:35 发布
最新推荐文章于 2023-03-18 21:15:35 发布
阅读量1.2k 收藏 9
点赞数 1
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Refrigeratorma/article/details/104727150
版权
BeanPostProcessor

在开始之前先介绍一下BeanPostProcessor（后置处理器）BeanPostProcessor接口作用是：在Spring容器完成Bean的实例化、配置和其他的初始化前后添加一些自己的逻辑处理。

方法说明
postProcessBeforeInitialization实例化、依赖注入完毕，在调用显示的初始化之前完成一些定制的初始化任务
postProcessAfterInitialization实例化、依赖注入、初始化完毕时执行
@autowired注解两个个比较重要的类 AbstractAutowireCapableBeanFactory

AbstractAutowireCapableBeanFactory的doCreateBean 主要干了三件事

方法说明
instantiate bean实例化 bean
populate bean为 bean 设置 property 参数
initialize bean初始化 bean（对创建好的 bean 做一些修饰动作）

该图片取自网络
在这里插入图片描述

现在开始讲解自动装配的流程

第一步：创建bean

类方法说明
AbstractBeanFactorydoGetBean先从缓存中寻找是否存在对应bean，没有则创建
DefaultSingletonBeanRegistrygetSingleton查询是否有对应的单例bean，没有则创建
AbstractAutowireCapableBeanFactorycreateBean向下调用创建bean
AbstractAutowireCapableBeanFactorydoCreateBean实例化、填充属性
AbstractAutowireCapableBeanFactorycreateBeanInstance向下调用创建bean
AbstractAutowireCapableBeanFactoryapplyMergedBeanDefinitionPostProcessors合并bean的处理信息

我们从doCreateBean开始看起

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
        //尝试从缓存中
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }
//如果缓存中没有，则根据对应的策略创建bean(RootBeanDefinition) 
//使用其构造函数 constructor 使用Java 反射实例化了 bean
        if (instanceWrapper == null) {
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }
		----省略一部分代码----
        synchronized(mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                //第一大步
                //调用MergedBeanDefinitionPostProcessor 后处理器，合并bean的定义信息
            //Autowire等注解信息就是在这一步完成预解析，并且将注解需要的信息放入缓存
                    this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable var17) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
                }
                mbd.postProcessed = true;
            }
        }
----省略一部分代码----
        try {
        // 对bean属性进行填充，注入bean中的属性，会递归初始化依赖的bean
            this.populateBean(beanName, mbd, instanceWrapper);
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) {
            if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                throw (BeanCreationException)var18;
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
        }
        ----省略一部分代码----
  • 第一步 缓存中是否存在bean，若不存在，则根据策略创建bean
  • 第二步 调用MergedBeanDefinitionPostProcessor，预解析@autowired注解的类
  • 第三步 将所有属性都注入到创建的bean中
    再看用于预解析的applyMergedBeanDefinitionPostProcessors方法
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
        Iterator var4 = this.getBeanPostProcessors().iterator();
//循环调用MergedBeanDefinitionPostProcessor接口的类的postProcessMergedBeanDefinition方法
        while(var4.hasNext()) {
            BeanPostProcessor bp = (BeanPostProcessor)var4.next();
            if (bp instanceof MergedBeanDefinitionPostProcessor) {
                MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor)bp;
                bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
            }
        }
    }

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

首先findAutowiringMetadata就是查询构建autowire元数据

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)) {
            Map var6 = this.injectionMetadataCache;
            synchronized(this.injectionMetadataCache) {
                metadata = (InjectionMetadata)this.injectionMetadataCache.get(cacheKey);
                if(InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if(metadata != null) {
                        metadata.clear(pvs);
                    }
 //构建Autowired元数据
                    metadata = this.buildAutowiringMetadata(clazz);
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }
 
        return metadata;
    }

private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
        ArrayList elements = new ArrayList();
        Class targetClass = clazz;
 
        do {
            ArrayList currElements = new ArrayList();
            //遍历这个类的所有的field去寻找又Autowired修饰的field
            ReflectionUtils.doWithLocalFields(targetClass, (field) -> {
                AnnotationAttributes ann = this.findAutowiredAnnotation(field);
                if(ann != null) {
                    //如果这个field是静态static的就警告并停止
                    if(Modifier.isStatic(field.getModifiers())) {
                        if(this.logger.isWarnEnabled()) {
                            this.logger.warn("Autowired annotation is not supported on static fields: " + field);
                        }
 
                        return;
                    }
                    //这里就取了Autowired的一个required属性，这个属性的作用是
                    //如果这个是false就表明在自动装配的时候没有发现又对应的实例
                    //就跳过去，如果是true没有发现有与之匹配的就会抛出个异常，仅此而已
                    boolean required = this.determineRequiredStatus(ann);
                    currElements.add(new AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement(field, required));
                }
 
            });
            //接着是遍历这个类里面的方法
            ReflectionUtils.doWithLocalMethods(targetClass, (method) -> {
                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
                if(BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                    AnnotationAttributes ann = this.findAutowiredAnnotation(bridgedMethod);
                    //同样的静态方法不能自动装配
                    if(ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                        if(Modifier.isStatic(method.getModifiers())) {
                            if(this.logger.isWarnEnabled()) {
                                this.logger.warn("Autowired annotation is not supported on static methods: " + method);
                            }
 
                            return;
                        }
 
                        if(method.getParameterCount() == 0 && this.logger.isWarnEnabled()) {
                            this.logger.warn("Autowired annotation should only be used on methods with parameters: " + method);
                        }
 
                        boolean required = this.determineRequiredStatus(ann);
                        PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                        currElements.add(new AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement(method, required, pd));
                    }
 
                }
            });
            elements.addAll(0, currElements);
            targetClass = targetClass.getSuperclass();
        } while(targetClass != null && targetClass != Object.class);
        return new InjectionMetadata(clazz, elements);
    }
  • 第一步 将标记@Autowired的字段封装为AutowiredFieldElement对象。
  • 第二步 将标记@Autowired的方法并且此方法是字段的getter或setter方法封装到AutowiredMethodElement对象
public void checkConfigMembers(RootBeanDefinition beanDefinition) {
        LinkedHashSet checkedElements = new LinkedHashSet(this.injectedElements.size());
        //injectedElements这个集合就是类里面所有被Autowired修饰过的field或method
        Iterator var3 = this.injectedElements.iterator();
        //遍历这个集合
        //把method或者field放入externallyManagedConfigMembers缓存中
        while(var3.hasNext()) {
            InjectionMetadata.InjectedElement element = (InjectionMetadata.InjectedElement)var3.next();
            Member member = element.getMember();
            if(!beanDefinition.isExternallyManagedConfigMember(member)) {
                beanDefinition.registerExternallyManagedConfigMember(member);
                checkedElements.add(element);
                if(logger.isDebugEnabled()) {
                    logger.debug("Registered injected element on class [" + this.targetClass.getName() + "]: " + element);
                }
            }
        }
 
        this.checkedElements = checkedElements;
    }

整个postProcessMergedBeanDefinition的工作就此完成，总结一下就是扫描类中被@autowired注释并且非static的字段域或方法，并且存放到内存中
接下来就要开始属性注入了
即doCreateBean中的populateBean方法

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
       //如果实例为空但是还有属性，抛出异常
            if(bw == null) {
            if(mbd.hasPropertyValues()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
        } else {
            boolean continueWithPropertyPopulation = true;
            //这边主要是根据InstantiationAwareBeanPostProcessor 判断是否继续给该bean配置属性
            if(!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                Iterator pvs = this.getBeanPostProcessors().iterator();
 
                while(pvs.hasNext()) {
                    BeanPostProcessor hasInstAwareBpps = (BeanPostProcessor)pvs.next();
                    if(hasInstAwareBpps instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor needsDepCheck = (InstantiationAwareBeanPostProcessor)hasInstAwareBpps;
                        if(!needsDepCheck.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                            continueWithPropertyPopulation = false;
                            break;
                        }
                    }
                }
            }
 
            if(continueWithPropertyPopulation) {
                Object pvs1 = mbd.hasPropertyValues()?mbd.getPropertyValues():null;
                //判断如果是按照名字或者类型注入的就进入这条分支
                if(mbd.getResolvedAutowireMode() == 1 || mbd.getResolvedAutowireMode() == 2) {
                    MutablePropertyValues hasInstAwareBpps1 = new MutablePropertyValues((PropertyValues)pvs1);
                    if(mbd.getResolvedAutowireMode() == 1) {
                        this.autowireByName(beanName, mbd, bw, hasInstAwareBpps1);
                    }
 
                    if(mbd.getResolvedAutowireMode() == 2) {
                        this.autowireByType(beanName, mbd, bw, hasInstAwareBpps1);
                    }
 
                    pvs1 = hasInstAwareBpps1;
                }
 
                boolean hasInstAwareBpps2 = this.hasInstantiationAwareBeanPostProcessors();
                boolean needsDepCheck1 = mbd.getDependencyCheck() != 0;
                if(hasInstAwareBpps2 || needsDepCheck1) {
                    if(pvs1 == null) {
                        pvs1 = mbd.getPropertyValues();
                    }
 
                    PropertyDescriptor[] filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    if(hasInstAwareBpps2) {
                        Iterator var9 = this.getBeanPostProcessors().iterator();
 
                        while(var9.hasNext()) {
                            BeanPostProcessor bp = (BeanPostProcessor)var9.next();
//这里循环调用了InstantiationAwareBeanPostProcessor实现类的postProcessPropertyValues
//方法,我们Autowire注解解析类AutowiredAnnotationBeanPostProcessor也是该接口的实现类
                            if(bp instanceof InstantiationAwareBeanPostProcessor) {
                                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                                pvs1 = ibp.postProcessPropertyValues((PropertyValues)pvs1, filteredPds, bw.getWrappedInstance(), beanName);
                                if(pvs1 == null) {
                                    return;
                                }
                            }
                        }
                    }
 
                    if(needsDepCheck1) {
                        this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs1);
                    }
                }
 
                if(pvs1 != null) {
                    this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs1);
                }
            }
        }
    }
最后做个总结

总的来说 IOC自动装配分为三步
第一步：实例化bean
第二步：填充属性参数
第三步：初始化bean

参考博客：
https://blog.csdn.net/nuomizhende45/article/details/84960303

https://www.shangyang.me/2017/04/01/spring-core-container-sourcecode-analysis-beans-instantiating-process/

https://www.shangyang.me/2017/04/05/spring-core-container-sourcecode-analysis-annotation-autowired/

马冰箱
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
41.使用@Autowired注解自动装配的过程是怎样的?
weixin_43860634的博客
01-03 423
41.使用@Autowired注解自动装配的过程是怎样的?
Spring@Autowired注解与自动装配.rar
09-16
Spring@Autowired注解与自动装配.rar
基于Spring@Autowired注解与自动装配详谈
08-29
下面小编就为大家带来一篇基于Spring@Autowired注解与自动装配详谈。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
彻底搞明白Spring中的自动装配和Autowired注解的使用
08-26
主要介绍了彻底搞明白Spring中的自动装配和Autowired注解的使用，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring In Action-2.1-01-@Component注解
08-31
package soundsystem; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @RunWith(SpringJUnit4ClassRunner.class)//Spring的Junit测试，会在测试开始时，创建Spring的应用上下文 @ContextConfiguration(classes=CDPlayerSpringConfig.class)//表明配置类 public class SpringTest1 { //自动装配 @Autowired private SgtPeppers sp; @Test public void instanceSpring(){ sp.play(); } }
Spring原理（Bean的生命周期、Bean 后处理器、BeanFactory 后处理器）
weixin_48542526的博客
03-18 340
先获得加了@注解的成员变量类型，然后封装成一个dependencydescriptor对象，在调用beanfactory的一个方法把这个对象传进去，用来搜索bf中是否存在这个类型的对象，如果存在，就用反射方法，获取它的set方法，并把值传给加了注解的成员变量。但这种说法是不完整的。首先获取有@Bean注解的源文件信息，然后在这个文件中获取有标注@Bean的方法的源文件信息。这个是设定自动注解模式，因为工厂类方法有一个需要传参的方法，如果没有配置传参的bean就会报错，这样设置就不报错了。
Spring框架中@Autowired实现自动装配的过程
仙草不加料的博客
10-24 2170
Spring框架在很大程度上为程序业务开发降低了耦合关系，@Autowired自动装配就是Spring IOC和DI核心思想的体现，通过将对象的控制权转交给Spring框架，由IOC容器在运行时向每个bean对象注入所依赖的另一个bean对象，从而实现自动装配。
Spring中@Autowired注解装配流程
浪丶荡
07-02 790
众所周知，Autowired注解是通过AutowiredAnnotationBeanPostProcessor来解析的第一个问题AutowiredAnnotationBeanPostProcessor在哪里注册的？过程比较复杂，在使用xml和注解不同的场景中，略有不同，具体可以参考如下文章：xml开发方式下AutowiredAnnotationBeanPostProcessor的注册时机https://blog.csdn.net/leisure_life/article/details/125570942?
Spring框架学习之06---@Autowired注解自动装配流程
qq_42682991的博客
02-16 1206
@Autowired自动装配的流程： @Autowired private LoaderTaskService loaderTaskService; @Autowired首先是按照类型（如LoaderTaskService类型）去容器中找相应的组件 类似于loaderTaskService = ioc.getBean(LoaderTaskService.Class)这样的效果。 1、找到一个就直接装配上 2、找不到的话就会抛异常 3、找到多个的话就再以默认变量名（如loade
使用@Autowired注解自动装配的过程是怎样的？
lamwolf的博客
01-02 411
在启动spring IOC时，容器自动装载了一个AutowiredAnnotationBeanPostProcessor后置处理器，当容器扫描到@Autowired、@Resource或@Inject时，就会在IOC容器自动查找需要的bean,并装配对该对象的属性。使用@Autowired注解来自动装配指定的bean。● 如果查询结果刚好为一个，就将该bean装配给@Autowired指定的数据；● 如果查询的结果不止一个，那么@Autowired会根据名称来查找；
Autowired自动配置的过程
m0_66947503的博客
10-24 751
是根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean，并将其与属性自动装配，当我们根据byName进行自动装配时，就需要使用到@Qualifier注解来手动指定一个beanid来进行装配。@Autowired用在字段上时，表示Spring会对该字段进行匹配赋值，在Spring容器中查找，找到能匹配到该字段的对象，进行赋值，找不到就抛出异常。当容器内存在一个和指定的属性类型相同的bean时，那么将和这个属性自动的进行装配，当存在多个该类型的bean，将会抛出异常。
autopvs1:用于归零变量的PVS1解释的自动分类工具
05-25
AutoPVS1 用于归零变量的PVS1解释的自动分类工具。 还提供了AutoPVS1的网络版本： ://autopvs1.genetics.bgi.com/ 前提条件 1.变量效果预测器（VEP） autopvs1使用确定您的变体（SNV，插入，缺失，CNV）对基因，转录本和蛋白质序列的影响。 要获取该变体的HGVS名称，应使用homo_sapiens_refseq 100_GRCh37缓存。 # VEP Installation git clone https://github.com/Ensembl/ensembl-vep.git cd ensembl-vep git pull git checkout release/100 perl INSTALL.pl 2. pyfaidx Samtools提供了一个“ faidx”（FAsta InDeX）函数，该函数创建一个
Spring @Autowired注解和静态方法 、静态变量的初始化顺序 以及PropertySource注解的配置使用问题
qq_38243970的博客
07-02 6483
问题1：加载顺序问题：conf.properites配置如下：fetchJobsSchedule=0 25 0 * * ? updateJobsSchedule=0 12 17 * * ? java代码配置如下：@Component @PropertySource("classpath:conf.properties") public class FetchStockSchedule { ...
Sprin中Bean的顺序
热门推荐
u014365523的博客
09-29 1万+
Bean顺序
Spring的Bean的生命周期与自动注入细节
qq_29003363的博客
02-15 610
Spring的Bean生命周期以及自动注入的实现细节
Spring：@Autowired自动装配的实现原理
记录点点滴滴的成长。
07-25 937
Spring：@Autowired自动装配的实现原理
@Autowired的自动装配原理
qq_46853052的博客
10-24 1827
@Autowired属于方法级别注解，可修饰构造器方法、Setter方法、普通方法，替换了autowire属性自动装配（按照类型装配，通过set方法，且方法可以省略）语法：@Autowired(required="true")属性参数:required==>是否为必须注入项作用：自动注入一个符合类型要求的bean
@Autowired自动装配原理
weixin_68286174的博客
07-24 1871
@Autowired自动装配原理
Spring boot @Autowired注解无法自动装配
最新发布
06-12
可能有几个原因导致@Autowired注解无法自动装配： 1. 检查你是否已经在类路径中包含了正确的依赖，例如spring-boot-starter-web等。如果这些依赖没有正确地配置，@Autowired注解就无法正常工作。 2. 检查你要注入的组件是否正确地标记为一个Spring bean。可以使用@Component，@Service，@Repository，@Controller等注解来标记组件。 3. 检查你的组件扫描路径是否正确。如果组件不在你的Spring应用程序的扫描路径中，@Autowired注解就无法找到并注入组件。 4. 检查你的代码是否正确地使用了@Autowired注解。确保它被注释在需要注入的字段或构造函数上。 5. 最后，如果以上解决方案都无法解决问题，请尝试使用明确的bean名称来注入组件。例如：@Autowired @Qualifier("myComponent") MyComponent myComponent;

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值