springboot相关逻辑
1. main启动类
首先就是springboot项目习以为常的main方法调用SpringApplication.run将标注有@SpringBootApplication注解的class对象作为参数传递。SpringBootApplication注解是个组合注解，主要组合了@Configuration，@EnableAutoConfiguration,@Import(AutoConfigurationImportSelector.class)， @ComponentScan等关键注解。
@SpringBootApplication
public class SampleWebUiApplication {
public static void main(String[] args) {
SpringApplication.run(SampleWebUiApplication.class, args);
}
}
2. 调用SpringApplication构造函数
通过第一步调用静态方法run，内部转换为实例化SpringApplication并调用实例方法run。
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
this.webApplicationType = WebApplicationType.deduceFromClasspath();
/**
* 通过getSpringFactoriesInstances 方法从META-INF/spring.factories文件中获取所有ApplicationContextInitializer 回调接口，
* 用于在刷新之前初始化Spring ConfigurableApplicationContext。
* 通常在需要对应用程序上下文进行一些编程初始化的Web应用程序中使用。
* 例如，注册属性源或针对上下文环境激活配置文件。
* 有关分别声明“ contextInitializerClasses”上下文参数和初始化参数的信息，请参见ContextLoader和FrameworkServlet支持。
* 鼓励ApplicationContextInitializer处理器检测是否已实现Spring的Ordered接口，或者是否存在@Order注释，并在调用之前对实例进行相应的排序。
*/
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
this.mainApplicationClass = deduceMainApplicationClass();
}
SpringApplication#getSpringFactoriesInstances 从"META-INF/spring.factories"中加载并实例化给定类型的所有实现类
ClassLoader classLoader = getClassLoader();
// Use names and ensure unique to protect against duplicates
// 使用给定的类加载器从“META-INF/spring.factories”中加载给定类型的所有实现类全限定名。
Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
// 通过反射实例化所有从上面获取的全限定类名
List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
AnnotationAwareOrderComparator.sort(instances);
return instances;
3. 调用SpringApplication实例对象的run方法
SpringApplication#run
...... 忽略部分代码
try {
...
// 1. 通过反射实例化ApplicationContext
// 2. 实例化applicationContext时调用其无参构造函数实例化AnnotatedBeanDefinitionReader，ClassPathBeanDefinitionScanner
// 3. 实例化AnnotatedBeanDefinitionReader时构造函数通过AnnotationConfigUtils.registerAnnotationConfigProcessors注册一些内部必要的BeanDefinition
// 如 ConfigurationClassPostProcessor(处理@Configuration @Import等注解), AutowiredAnnotationBeanPostProcessor(自动注入)等。
context = createApplicationContext();
exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
new Class[]{ConfigurableApplicationContext.class}, context);
// 1. 调用从spring.factories加载的
// 2. 加载primarySources以及sources到BeanDefinition(用于解析@SpringBootApplication,通过ConfigurationClassPostProcessor)
prepareContext(context, environment, listeners, applicationArguments, printedBanner);
// 1. 调用AbstractApplicationContext#refresh方法
// 2. 通过调用invokeBeanFactoryPostProcessors方法调用ConfigurationClassPostProcessor处理primarySources类的注解
// 3. ConfigurationClassPostProcessor处理@SpringBootApplication的元注解@ComponentScan扫描包组件注册到BeanDefinitionRegistry
// 4. ConfigurationClassPostProcessor通过@EnableAutoConfiguration的元注解@Import中的AutoConfigurationImportSelector自动导入spring.factories中的类到BeanDefinitionRegistry
// 5.启动内置web容器(调用ServletWebServerApplicationContext#onRefresh)
refreshContext(context);
afterRefresh(context, applicationArguments);
...
} catch (Throwable ex) {
...
}
try {
listeners.running(context);
} catch (Throwable ex) {
...
}
return context;
SpringApplication#createApplicationContext 用于创建ApplicationContext的策略方法,默认情况下，此方法将使用任何明确设置的应用程序上下文或应用程序上下文类，然后再使用合适的默认值。
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch (this.webApplicationType) {
case SERVLET:
//org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext
contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
break;
case REACTIVE:
// org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext
contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
break;
default:
// org.springframework.context.annotation.AnnotationConfigApplicationContext
contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
}
} catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);
}
}
// 通过反射实例化context,在对应ApplicationContext的构造方法中实例化{@link AnnotatedBeanDefinitionReader
// 并在该reader的构造方法中通过{@link AnnotationConfigUtils#registerAnnotationConfigProcessors}
// 注册一些内部必要的BeanDefinition如：{@link ConfigurationClassPostProcessor},{@link AutowiredAnnotationBeanPostProcessor}等
return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
上诉方法最后一步反射实例化应用上下文时，很关键的一步就是向容器中注册一些非常重要的的BeanDefinition（如：ConfigurationClassPostProcessor，AutowiredAnnotationBeanPostProcessor等），主要步骤：AnnotationConfigServletWebServerApplicationContext() -> new AnnotatedBeanDefinitionReader -> AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)
AnnotationConfigUtils.registerAnnotationConfigProcessors 注册spring内部必要的一些beanDefinition
···
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
// 在Spring#refresh时调用invokeBeanFactoryPostProcessors(beanFactory)方法时调用，用来处理@Configuration @Import等注解
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
// CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME = "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
...
下图断点为createApplicationContext方法执行结束后，beanDefinitionMap中的内容
createApplicationContext执行结束后beanDefinitionMap值
SpringApplication#prepareContext 准备上下文
...
// 调用从spring.factories获取的ApplicationContextInitializer
applyInitializers(context);
...
// 获取所有资源，如在main方法中传进来的SampleWebUiApplication.class等
Set<Object> sources = getAllSources();
Assert.notEmpty(sources, "Sources must not be empty");
// 将资源注册为BeanDefinition
load(context, sources.toArray(new Object[0]));
listeners.contextLoaded(context);
下图断点为prepareContext方法执行结束后，beanDefinitionMap中的内容
prepareContext执行结束后beanDefinitionMap值
SpringApplication#refreshContext 刷新上下文具体如下。
spring refresh之invokeBeanFactoryPostProcessors
调用ConfigurationClassPostProcessor整体流程图
AbstractApplicationContext#refresh
......
// 调用实现BeanFactoryPostProcessor的后置处理器，
// 其实就是在上述new AnnotatedBeanDefinitionReader时注册的解析配置类的后置处理器ConfigurationClassPostProcessor
// 这里主要解析SpringBootApplication元注解中的Import注解以及ComponentScan注解等。
invokeBeanFactoryPostProcessors(beanFactory);
......
AbstractApplicationContext#invokeBeanFactoryPostProcessors
//由于之前注册的都是BeanDefinition,此时还并没有生产任何的BeanFactoryPostProcessor，所以getBeanFactoryPostProcessors是空的
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors 从beanDefinitionMap中获取实现了BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor接口的实现类，并调用
//放置已处理的beanName
Set<String> processedBeans = new HashSet<>();
//放置常规的后置处理器，就是只实现了BeanFactoryPostProcessor接口的
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
//放置实现了BeanDefinitionRegistryPostProcessor接口的，之前我们注册的后置处理器中只有ConfigurationClassPostProcessor实现了
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
//放置当前的RegistryProcessors
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
//查找实现了BeanDefinitionRegistryPostProcessor接口的BeanName,其实目前就只有一个ConfigurationClassPostProcessor
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//ConfigurationClassPostProcessor同样实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//调用了getBean方法，产生了ConfigurationClassPostProcessor实例,放到currentRegistryProcessors集合中
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
//排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//将实例化出来的后置处理器放到集合中
registryProcessors.addAll(currentRegistryProcessors);
// 调用ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//清空，以便处理后面的后置处理器
currentRegistryProcessors.clear();
//再次查找实现了BeanDefinitionRegistryPostProcessor接口的BeanName，这里就是可能就是从配置类中解析出来的一些
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//不包括已经处理过的，并且先处理实现Ordered接口的
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
//根据Ordered排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//将后置处理器放到已注册的集合中
registryProcessors.addAll(currentRegistryProcessors);
//调用所有后置处理器的postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//再次清理，因为后面还要处理未实现Ordered接口的
currentRegistryProcessors.clear();
......
ConfigurationClassPostProcessor#processConfigBeanDefinitions 处理@Configuration注解以及相关的@Bean,@Import等注解
//放置候选配置类
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
String[] candidateNames = registry.getBeanDefinitionNames();
//遍历之前注册的所有bean定义，找到其中的配置类，其实就是我们自己传进来的配置类
for (String beanName : candidateNames) {
//...省略校验过程...
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
//检查是否是有@Configuration注解的BeanDifinition -> full类型的配置类 -> 会把配置类替换成动态代理类
//或者该类包含@Component @ComponentScan @Import @ImportResource @Bean 注解的其中之一 -> lite类型的配置类 -> 不会替换成动态代理类
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);
do {
//解析配置类
parser.parse(candidates);
parser.validate();
//parser.getConfigurationClasses()就是拿到刚刚解析完放到map中的配置类
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
//这里处理@Import导入的beanDefintion和配置类中的@Bean
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
//以下逻辑是找出未解析的配置类，如@Bean和ImportBeanDefinitionRegistrar所引入的
candidates.clear();
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
//将是配置类并且没有解析过的BeanDefinition放到候选集合中继续解析
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
ConfigurationClassUtils.checkConfigurationClassCandidate 检查给定的bean定义是否是配置类（或在配置类/组件类中声明的嵌套类，也要自动注册），并进行相应标记。
...
//检查是否有标识@Configuration
Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());
if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
//设置配置属性值为full
beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
}
//检查是否包含@Component @ComponentScan @Import @ImportResource @Bean
else if (config != null || isConfigurationCandidate(metadata)) {
//设置配置属性值为lite
beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
}
else {
return false;
}
经过checkConfigurationClassCandidate后，此时容器中只有启动类属于配置类，进行解析的只有该类，当然后续还有解析出来的其他配置类会在while里继续解析
第一次需要解析的配置类
ConfigurationClassParser#parse 配置类解析流程
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
// 配置类的beanDefinition为AnnotatedGenericBeanDefinition
if (bd instanceof AnnotatedBeanDefinition) {
//传入配置类的元数据与beanName
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
......
}
// 处理实现了DeferredImportSelector接口的实现类，用来延迟处理@Import
// @EnableAutoConfiguration注解导入的AutoConfigurationImportSelector就属于该类型
this.deferredImportSelectorHandler.process()
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}
ConfigurationClassParser#processConfigurationClass
...
SourceClass sourceClass = asSourceClass(configClass, filter);
do {
//解析配置类，这里可能返回配置类的父类，需要继续处理
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
//将配置类放入map中
this.configurationClasses.put(configClass, configClass);
ConfigurationClassParser#doProcessConfigurationClass
......
//@Configuration 本身也是 @Component的组合注解
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// 处理内置类，如果内置类也是个配置类，递归处理内置类
processMemberClasses(configClass, sourceClass, filter);
}
// Process any @ComponentScan annotations
// 找出配置类上的@ComponentScan注解属性
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
for (AnnotationAttributes componentScan : componentScans) {
//将@ComponentScan引入的所有类扫描成BeanDefinition并注册到容器中
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
//这里循环是为了判断扫描出来的beanDefinition是否是配置类，如果是配置类的话需要递归解析
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
//这里是必然为true, 能被扫描出来的必然有@Component注解，而@Component注解为lite配置类
//这里主要是为了在检查的同时设置一下full或者lite的类型
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
//配置类就继续递归解析
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
// 处理@Import注解
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
...
// 将配置类中@Bean的方法解析成方法元数据放到配置类中
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
...
ConfigurationClassParser#processImports 处理@Import注解
//importCandidates为@Import中的value数组
for (SourceClass candidate : importCandidates) {
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports
Class<?> candidateClass = candidate.loadClass();
//实例化我们写的实现ImportSelector接口的类
ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
this.environment, this.resourceLoader, this.registry);
if (selector instanceof DeferredImportSelector) {
// 如果是实现了延迟导入，则用延迟导入方式导入
// 将其加入到deferredImportSelectors数组中，待全部处理完后在ConfigurationClassParser#parse方法最后进行处理导入
// @EnableAutoConfiguration注解导入的AutoConfigurationImportSelector就属于该类型
this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
} else {
//调用selectImports方法返回我们需要注入到容器中bean数组
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
//转为SourceClass集合
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
//再次递归调用本方法，如果我们返回的数组是一些没有实现Import相关接口的类，
//就会走到最后的else逻辑，当成配置类处理
processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
}
}
//这里就走实现ImportBeanDefinitionRegistrar接口的逻辑
else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
// Candidate class is an ImportBeanDefinitionRegistrar ->
// delegate to it to register additional bean definitions
Class<?> candidateClass = candidate.loadClass();
//实例化
ImportBeanDefinitionRegistrar registrar =
ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
this.environment, this.resourceLoader, this.registry);
//这里先把Registrar放到配置类的importBeanDefinitionRegistrars属性中，最后解析完调用loadBeanDefinition进行处理
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}
else {
//普通的bean当做配置类处理
processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
}
}
处理完上述方法后回到ConfigurationClassParser#parse的最后一步处理DeferredImportSelector接口实现类（this.deferredImportSelectorHandler.process()），调用ConfigurationClassParser.DeferredImportSelectorGroupingHandler#processGroupImports
此时只有该延迟处理的导入类
ConfigurationClassParser.DeferredImportSelectorGrouping#getImports 获取DeferredImportSelector导入的条目
for (DeferredImportSelectorHolder deferredImport : this.deferredImports {
// 调用AutoConfigurationImportSelector.AutoConfigurationGroup#process获取需要自动导入的配置类
this.group.process(deferredImport.getConfigurationClass().getMetadata(),
deferredImport.getImportSelector());
}
return this.group.selectImports();
AutoConfigurationImportSelector.AutoConfigurationGroup#process 获取需要自动导入的配置类信息
// 从META-INFO/spring.factories文件下获取EnableAutoConfiguration对应的配置类列表
AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
.getAutoConfigurationEntry(annotationMetadata);
this.autoConfigurationEntries.add(autoConfigurationEntry);
for (String importClassName : autoConfigurationEntry.getConfigurations()) {
this.entries.putIfAbsent(importClassName, annotationMetadata);
}
AutoConfigurationImportSelector#getAutoConfigurationEntry
...
// 从META-INFO/spring.factories文件下获取EnableAutoConfiguration对应的配置类列表
List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
configurations = removeDuplicates(configurations);
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
configurations = getConfigurationClassFilter().filter(configurations);
fireAutoConfigurationImportEvents(configurations, exclusions);
return new AutoConfigurationEntry(configurations, exclusions);
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
// 从META-INFO/spring.factories文件下获取org.springframework.boot.autoconfigure.EnableAutoConfiguration对应的配置类列表
// getSpringFactoriesLoaderFactoryClass() -> EnableAutoConfiguration.class
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "+ "are using a custom packaging, make sure that file is correct.");
return configurations;
}
执行完getCandidateConfigurations获取到的配置列表
getCandidateConfigurations获取到的配置类列表
最后回到ConfigurationClassPostProcessor#processConfigBeanDefinitions方法中的的this.reader.loadBeanDefinitions(configClasses)将解析出来的类注册到beanDefinitionMap，之后在refresh的finishBeanFactoryInitialization方法中实例化这些bean。
加载后beanDefinitionMap中的值
网友评论