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

梦里梦外; 2024-02-05 21:50 48阅读 0赞

### 一、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**  
![在这里插入图片描述][19cbfcd1a6764f358ece7ed4214c504c.png]

#### 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)方法 ####

![在这里插入图片描述][79d04e9627c542c6b34d59ea15a74fb0.png]

#### 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 ###

略：百度搜

[19cbfcd1a6764f358ece7ed4214c504c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/54c8651671474559af91e52d6b0fad71.png
[79d04e9627c542c6b34d59ea15a74fb0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/42306dbffa5f4b6391ebaecf7524bcda.png