spring-boot源码解析二@SpringBootApplication注解加载流程

客官°小女子只卖身不卖艺 2022-11-09 12:59 221阅读 0赞

### 文章目录 ###

*  加载启动类包下所有声明注解对象
 *  加载spring-boot默认配置

# 加载启动类包下所有声明注解对象 #

首先执行invokeBeanFactoryPostProcessors

public void refresh() throws BeansException, IllegalStateException {
        
    		synchronized (this.startupShutdownMonitor) {
        
    
    ...
    //激活各种BeanFactory处理器
    				//BeanFactoryPostProcessor作用域容器级,仅仅对容器中的bean进行后置处理,如propertyPlaceholderConfig,继承order可实现排序调用功能
    				//BeanPostProcessor可以修改实际的bean实例
    invokeBeanFactoryPostProcessors(beanFactory);
    ...
    	}

接下来会从容器中寻找实现了BeanDefinitionRegistryPostProcessor接口的对象,该对象会先BeanFactoryPostProcessor接口实现类执行

public static void invokeBeanFactoryPostProcessors(
    			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        
    
    ...
    			//当前处理器执行执行postProcessBeanDefinitionRegistry方法
    			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
    ...
    	}

在这里执行的ConfigurationClassPostProcessor类,该类主要用来注入标识了@Configuration，@Component，@ComponentScan，@Import，@ImportResource的类.  
![在这里插入图片描述][20210315161927862.png]  
该类是在新建spring容器的时候，注入进去的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70]  
解析每个 @Configuration class，在这里其实是main函数启动类。@SpringBootApplication = 》  
@SpringBootConfiguration =》@Configuration

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
        
    ...
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    
    	for (String beanName : candidateNames) {
        
    			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
    			if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
        
    				if (logger.isDebugEnabled()) {
        
    					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
    				}
    			}
    			//是否配置了@Configuration注解
    			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
        
    				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
    			}
    		}
    
    		Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    
    do {
        
    	parser.parse(candidates);
    		while (!candidates.isEmpty());
    ...
    }

递归处理超类

public void parse(Set<BeanDefinitionHolder> configCandidates) {
        
    		for (BeanDefinitionHolder holder : configCandidates) {
        
    			BeanDefinition bd = holder.getBeanDefinition();
    			try {
        
    				//如果BeanDefinition是注解则进入这里
    				if (bd instanceof AnnotatedBeanDefinition) {
        
    					parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
    				}
    				else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
        
    					parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
    				}
    				else {
        
    					parse(bd.getBeanClassName(), holder.getBeanName());
    				}
    			}
    			catch (BeanDefinitionStoreException ex) {
        
    				throw ex;
    			}
    			catch (Throwable ex) {
        
    				throw new BeanDefinitionStoreException(
    						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
    			}
    		}
    
    		this.deferredImportSelectorHandler.process();
    	}
    
    	protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
        
    		processConfigurationClass(new ConfigurationClass(metadata, beanName));
    	}
    
    
    protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
        
    		// Recursively process the configuration class and its superclass hierarchy.
    		SourceClass sourceClass = asSourceClass(configClass);
    		do {
        
    			//多次遍历,返回超类.
    			sourceClass = doProcessConfigurationClass(configClass, sourceClass);
    		}
    		while (sourceClass != null);
    
    		this.configurationClasses.put(configClass, configClass);
    	}

在此方法中完成了扫描包下所有bean.

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
    			throws IOException {
        
    ...
    
    	// Process any @ComponentScan annotations
    		//配置容器属性
    		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
    				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    		if (!componentScans.isEmpty() &&
    				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
        
    			for (AnnotationAttributes componentScan : componentScans) {
        
    				// The config class is annotated with @ComponentScan -> perform the scan immediately
    
    				//具体这里执行了扫描包下所有bean,并设置为BeanDefinitionHolder
    				Set<BeanDefinitionHolder> scannedBeanDefinitions =
    						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
    				// Check the set of scanned definitions for any further config classes and parse recursively if needed
    				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
        
    					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
    					if (bdCand == null) {
        
    						bdCand = holder.getBeanDefinition();
    					}
    					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
        
    						parse(bdCand.getBeanClassName(), holder.getBeanName());
    					}
    				}
    			}
    		}
    ...
    	}

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 1]

# 加载spring-boot默认配置 #

org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGrouping\#getImports

public Iterable<Group.Entry> getImports() {
        
    			for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
        
    				this.group.process(deferredImport.getConfigurationClass().getMetadata(),
    						deferredImport.getImportSelector());
    			}
    			return this.group.selectImports();
    		}

org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.AutoConfigurationGroup\#process

public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
        
    			Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
    					() -> String.format("Only %s implementations are supported, got %s",
    							AutoConfigurationImportSelector.class.getSimpleName(),
    							deferredImportSelector.getClass().getName()));
    //这里加载META-INF下EnableAutoConfiguration
    			AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
    					.getAutoConfigurationEntry(annotationMetadata);
    					
    			this.autoConfigurationEntries.add(autoConfigurationEntry);
    			for (String importClassName : autoConfigurationEntry.getConfigurations()) {
        
    				this.entries.putIfAbsent(importClassName, annotationMetadata);
    			}
    		}

public void processGroupImports() {
        
    			for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
        
    				Predicate<String> exclusionFilter = grouping.getCandidateFilter();
    		//获取导入的类名集合，也就是META-INF/spring.factories 文件
    				// EnableAutoConfiguration声明@Configuration的类
    				grouping.getImports()
    				.forEach(entry -> {
        
    					ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
    					try {
        
    											//导入类
    						processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter),
    								Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)),
    								exclusionFilter, false);
    					}
    					catch (BeanDefinitionStoreException ex) {
        
    						throw ex;
    					}
    					catch (Throwable ex) {
        
    						throw new BeanDefinitionStoreException(
    								"Failed to process import candidates for configuration class [" +
    										configurationClass.getMetadata().getClassName() + "]", ex);
    					}
    				});
    			}
    		}

[20210315161927862.png]: /images/20221023/e740e5aa51474203a915682b98e23cc9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70]: /images/20221023/291280f8cefe48b2bd4cd31b0d8a4f70.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 1]: /images/20221023/e5c1624661484390855a9531d4e8fb27.png