@AutoConfigurationPackage，@ComponentScan注解，扫描包及注册bean

已于 2024-01-05 15:34:20 修改
阅读量541 收藏 10
点赞数 10
分类专栏： Spring 文章标签： java spring spring boot
于 2024-01-04 10:18:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/riding_horse/article/details/135379946
版权
本文详细介绍了Spring框架中AnnotationConfigApplicationContext的启动过程，特别是ConfigurationClassPostProcessor在扫描包下带有@Component注解的类中的作用，以及如何通过AnnotatedBeanDefinitionReader处理配置元信息。
摘要由CSDN通过智能技术生成

一、AutoConfigurationPackage，ComponentScan注解详情

略：百度搜

二、spring加载流程之ConfigurationClassPostProcessor

2.1、AnnotationConfigApplicationContext：spring java配置方式启动

    public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
        this();
        this.register(componentClasses);
        this.refresh();
    }

2.2、this()构造方法

    public AnnotationConfigApplicationContext() {
        StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
        this.reader = new AnnotatedBeanDefinitionReader(this);
        createAnnotatedBeanDefReader.end();
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

2.3、AnnotatedBeanDefinitionReader理解，BeanDefinationReader

BeanDefinationReader：

Spring是如何看懂这些配置元信息的呢？这个就要靠我们的BeanDefinationReader了。不同的BeanDefinationReader拥有不同的功能，如果我们要读取xml配置元信息，那么可以使用XmlBeanDefinationReader。如果我们要读取properties配置文件，那么可以使用PropertiesBeanDefinitionReader加载。而如果我们要读取注解配置元信息，那么可以使用 AnnotatedBeanDefinitionReader加载。我们也可以很方便的自定义BeanDefinationReader来自己控制配置元信息的加载。总的来说，BeanDefinationReader的作用就是加载配置元信息，并将其转化为内存形式的BeanDefination，存在某一个地方，至于这个地方在哪里，不要着急，接着往下看！
————————————————
版权声明：本文为CSDN博主「张维鹏」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/a745233700/article/details/113840727

2.4、AnnotatedBeanDefinitionReader构造器

    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
        this.beanNameGenerator = AnnotationBeanNameGenerator.INSTANCE;
        this.scopeMetadataResolver = new AnnotationScopeMetadataResolver();
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        Assert.notNull(environment, "Environment must not be null");
        this.registry = registry;
        this.conditionEvaluator = new ConditionEvaluator(registry, environment, (ResourceLoader)null);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }

2.5、注册内部（spring自带配置类）AnnotationConfigUtils

类：AnnotationConfigUtils
在这里插入图片描述

2.6、AnnotationConfigUtils注册ConfigurationClassPostProcessor类

        Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet(8);
        RootBeanDefinition def;
        if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalConfigurationAnnotationProcessor")) {
            def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"));
        }

三、判断是否是配置类

3.1、AnnotationConfigApplicationContext

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();
    this.register(componentClasses);
    this.refresh();
}

3.2、this.refresh()

synchronized(this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                // ConfigurationClassPostProcessor处理配置类，扫描包下 @Component 注解类
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();

3.3、ConfigurationClassPostProcessor类postProcessBeanDefinitionRegistry方法

    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        int registryId = System.identityHashCode(registry);
        if (this.registriesPostProcessed.contains(registryId)) {
            throw new IllegalStateException("postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
        } else if (this.factoriesPostProcessed.contains(registryId)) {
            throw new IllegalStateException("postProcessBeanFactory already called on this post-processor against " + registry);
        } else {
            this.registriesPostProcessed.add(registryId);
            this.processConfigBeanDefinitions(registry);
        }
    }

3.4、ConfigurationClassPostProcessor类processConfigBeanDefinitions方法

判断是否是配置类
ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)

        for(int var6 = 0; var6 < var5; ++var6) {
            String beanName = var4[var6];
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
                }
            } else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
                configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
            }
        }

解析配置类


     ConfigurationClassParser parser = new ConfigurationClassParser(this.metadataReaderFactory, this.problemReporter, this.environment, this.resourceLoader, this.componentScanBeanNameGenerator, registry);
     Set<BeanDefinitionHolder> candidates = new LinkedHashSet(configCandidates);
     HashSet alreadyParsed = new HashSet(configCandidates.size());

四、扫描配置类

4.1、ConfigurationClassParser解析配置类

构造方法

    public ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory, ProblemReporter problemReporter, Environment environment, ResourceLoader resourceLoader, BeanNameGenerator componentScanBeanNameGenerator, BeanDefinitionRegistry registry) {
        this.metadataReaderFactory = metadataReaderFactory;
        this.problemReporter = problemReporter;
        this.environment = environment;
        this.resourceLoader = resourceLoader;
        this.registry = registry;
        this.componentScanParser = new ComponentScanAnnotationParser(environment, resourceLoader, componentScanBeanNameGenerator, registry);
        this.conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);
    }

4.2、ComponentScanAnnotationParser类public Set parse(AnnotationAttributes componentScan, String declaringClass)方法

在这里插入图片描述

4.3、ClassPathBeanDefinitionScanner类doScan方法

查找包下含有 @Component 注解的配
Set candidates = this.findCandidateComponents(basePackage);


    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet();
        String[] var3 = basePackages;
        int var4 = basePackages.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            String basePackage = var3[var5];
            // 查找包下含有 @Component 注解的配
            Set<BeanDefinition> candidates = this.findCandidateComponents(basePackage);
            Iterator var8 = candidates.iterator();

            while(var8.hasNext()) {
                BeanDefinition candidate = (BeanDefinition)var8.next();
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());
                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
                if (candidate instanceof AbstractBeanDefinition) {
                    this.postProcessBeanDefinition((AbstractBeanDefinition)candidate, beanName);
                }

                if (candidate instanceof AnnotatedBeanDefinition) {
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition)candidate);
                }

                if (this.checkCandidate(beanName, candidate)) {
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    this.registerBeanDefinition(definitionHolder, this.registry);
                }
            }
        }

        return beanDefinitions;
    }

五、注册bean

略：百度搜

8号看台
关注
专栏目录
@SpringBootApplication注解的使用
p1830095583的博客
04-24 358
一、前言 大部分的配置都可以用Java类+注解来代替，而在SpringBoot项目中见的最多的莫过于@SpringBootApplication注解了，它在每个SpringBoot的启动类上都有标注。 这个注解对SpringBoot的启动和自动配置到底有什么样的影响呢？本文将为各位大佬解析它的源码，揭开@SpringBootApplication注解神秘的面纱。 二、正文 对SpringBoot工程的自动配置很感兴趣，于是学习其源码并整理了其中一些内容，如果有错误请大家指正~话不多说，直接上源码； @Sp.
@AutoConfigurationPackage 和 @ComponentScan 有何区别？
ZL4120505的博客
04-13 650
注解主要是扫描 Spring 家族的各种 Bean，如 @Controller、@Service、@Component、@Repository 以及由此衍生出来的一些其他的 Bean，对于 Spring 家族之外的 Bean，如 MyBatis 的 @Mapper、@MapperScan，JPA 的 @Entity 等，解决这个问题的办法很简单，要么将启动类放到根包下面，这样所有的 Bean 默认就都能扫描到了，要么我们重新配置包扫描，这里我采用第二种方案，我们在启动类上加。
SpringBoot自动配置&properties文件配置项优先级
最新发布
qq_44027353的博客
07-02 1109
方法，去读取+过滤spring.factories文件中的自动配置类，并最终将selectImport()方法返回的自动配置类加载进Spring容器并解析。ImportSelect接口，解析配置类时在使用@Import注解，如果导入的类型是ImportSelect，所导入的配置类会直接进行解析导入。，在启动Spring容器时就会用到该配置类，通过解析该配置类最终会往Spring容器中添加很多的BeanDefinition。主要作用：Spring容器启动时使用配置类，而解析配置类的过程中就会用到这里的。
@AutoConfigurationPackage和@ComponentScan的作用是否冲突
MyCurlingStick的博客
05-04 676
@AutoConfigurationPackage和@ComponentScan的作用是否冲突
JAVA面试题分享三百九十八：@AutoConfigurationPackage 和 @ComponentScan 有何区别？
之乎者也·的博客
01-31 1064
该注解用于扫描指定包下的类，并将其作为自动配置包，以便系统能够扫描到包内的Bean。用于组件扫描，扫描指定包下的所有Spring组件，包括@Controller、@Service、@Repository等。默认情况下，Spring Boot会扫描启动类所在包及其子包下的所有组件思考:@AutoConfigurationPackage 和 @ComponentScan有什么区别?@Mapper或者在启动类上添加Mapper扫描注解，进行统一扫描Mapper接口这样配置有一个前提，启动类在所有类的最外层。
Spring Boot 中@Componentscan 和@EnableAutoConfiguration 的区别
a2352159950的博客
09-06 1534
问题引出 学习springboot配置原理的时候，注解@SpringBootApplication下有三个注解，@SpringBootApplication、@EnableAutoConfiguration以及@ComponentScan，感觉后两个都是包扫描的配置，有点分不清。这里做一个辨析： 区别 这两个注释之间的基本区别是@ComponentScan 扫描 Spring 组件，也就是我们平时开发用的@Controller/@Service/@Component/@Repository这些注解是由Co
【SpringBoot学习】@EnableAutoConfiguration 和 @ComponentScan区别示例
HD243608836的博客
02-19 615
代码地址： https://gitee.com/better-code/SpringBoot-Example/springboot01_1/ 代码结构： 具体代码使用： com.example.springboot01_1.web.HelloController @RestController public class HelloController { @RequestMapping("/hello") public String hello() { .
SpringBoot Application注解原理及代码详解
08-19
@AutoConfigurationPackage 注解的主要作用是自动配置包，会自动扫描主配置类（@SpringBootApplication 标注的类）的所在包以及下面所有子包里面的所有组件，并将其纳入到 Spring 容器中。 在 SpringBoot 应用程序...
@SpringBootApplication注解到底做了什么，你真的了解吗？
12-21
再来看`@ComponentScan`，它用于扫描指定包下的所有@Component、@Service、@Repository和@Controller等注解的类，将它们注册到Spring应用上下文中，使得我们可以进行依赖注入。`excludeFilters`属性允许我们排除特定...
详解SpringBoot自动装配原理及源码
wdj_yyds的博客
01-06 417
SpringBoot是对Spring的一种扩展，其中比较重要的扩展功能就是自动装配：通过注解对常用的配置做默认配置，简化xml配置内容。本文会对Spring的自动配置的原理和部分源码进行解析，本文主要参考了Spring的官方文档。 自动装配的组件 SpringBoot自动装配通过多部分组件协调完成，这些组件主要有下面几种，这几种组件之间协调工作，最终完成了SpringBoot的自动装配。 @EnableAutoConfiguration：用于根据用户所引用的jar包自动装配Spring容器，比如用户在
【SpringBoot】@SpringBootApplication注解分解
weixin_44075200的博客
02-20 347
核心注解@SpringBootApplication，由三个注解组成，分别是@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan。 同时承担了这三个注解的功能，分别是：1、说明这个类是一个配置类、开启自动配置、组件扫描。
@ComponentScan和@EnableAutoConfiguration的区别
qq_28050861的博客
11-10 867
https://blog.csdn.net/wangbiao007/article/details/101020426
@AutoConfigurationPackage和@ComponentScan的区别
lifetime_gear的博客
08-14 511
@AutoConfigurationPackage和@ComponentScan的区别，和@SpringBootApplication中为啥同时有这么两个注解。
@AutoConfigurationPackage注解详解
怪咖@的博客
10-23 8451
@AutoConfigurationPackage是在springboot启动类注解@SpringBootApplication下的@EnableAutoConfiguration下。@AutoConfigurationPackage作用是指定springboot扫描包，默认就是扫描启动类同包下的类。可以通过@AutoConfigurationPackage来附加其他路径，然后springboot同样会进行扫描。
启动类扫描的注解解析器 <context:component-scan base-package="com.tfy.oa"></context:component-scan>
tfy1332的专栏
03-18 2769
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"        xmlns:aop="http://www.springframework.org/schema/aop"        xmlns:tx="http://www.springframework.org/schema/tx"        xmlns:context="h
SpringBoot 自动扫描当前包的原理
weixin_34406796的博客
05-29 831
2019独角兽企业重金招聘Python工程师标准>>> ...
@AutoConfigurationPackage注解真正的作用
乖松鼠的博客
07-24 692
我们知道是实现自动配置的关键注解。其由构成。这里我们讨论下的作用，作者才疏学浅，望大家多多指正。
springboot自动装配的原理，springboot项目启动源码分析， @Import解析，@EnableAutoConfiguration解析，手写Starts包
世上哪有什么岁月静好,不过是有人替你负重前行
04-03 2106
文章目录springboot项目启动的本质springboot自动装配的核心原理**@EnableAutoConfiguration解析：**@AutoConfigurationPackage@Import解析方式一：静态使用方式方式二：动态使用方式被引用类实现了ImportSelector方式二：动态使用方式被引用类实现了ImportBeanDefinitionRegistrarAutoConfigurationImportSelector.class分析getCandidateConfiguration
@ComponentScan 注解
09-28
@ComponentScan 注解是 Spring 框架中的一个注解，用于自动扫描和注册 Spring Bean。通过使用 @ComponentScan 注解，Spring 容器将会扫描指定的包及其子包中的所有类，将被 @ComponentScan 注解标记的类实例化为 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值