SpringBoot的自动装配
-
-
-
- 大致流程
- 完整流程(结合源码)
-
- 启动类
- SpringApplication的构造方法
- run方法
- prepareContext()方法
- load()方法
- refreshContext()方法
- refresh()方法
- invokeBeanFactoryPostProcessors()方法
- ConfigurationClassPostProcessor类中的processConfigBeanDefinitions()方法
- ConfigurationClassParser类中的parse()方法
- ConfigurationClassParser类中的doProcessConfigurationClass()方法
- AutoConfigurationImportSelector类中的process()方法
- 至此,springboot的自动装配就完成了
-
-
大致流程
-
当启动SpringBoot应用程序的时候,会先创建SpringApplication对象,在构造方法中会进行一些参数的初始化工作,比如会加载Spring.factories文件,将文件的内容放到缓存对象中,方便后续获取
-
SpringApplication对象创建完成后,开始调用run方法,启动过程中最主要有两个方法,第一个叫prepareContext(),第二个叫refreshContext()方法
-
在prepareContext()方法主要是对上下文对象ConfigurableApplicationContext的初始化操作,在整个过程中有个非常重要的方法就是load()方法,它会将当前启动类作为一个BeanDefinition注册到BeanDefinitionMap中,方便后续在进行BeanFactoryPostProcessor调用执行的时候,找到对应的启动类,来完成对应注解的解析工作
-
在refreshContext()方法会进行整个Spring容器的刷新refresh操作,会调用spring的refresh()方法,自动装配过程是在invokeBeanFactoryPostProcessor方法()中进行(也就是执行BeanFactory的后置处理器),在此方法主要是针对ConfigurationClassPostProcessor类的处理
-
在执行BeanFactory后置处理器的时候会调用ConfigurationClassPostProcessor类中的parse()方法去解析处理各种注解比如@CompomentScan、@Import等等
-
在解析@Import注解的时候比较特别,会有一个collectImports()方法,从主类开始递归解析注解,把所有包含@Import的注解都解析到BeanDefinitionMap中
-
调用AutoConfigurationImportSelector类(相当于一个处理器)中的process()方法进而触发getCandidateConfigurations()方法获取Spring.factories文件下的key为EnableAutoConfiguration的所有value,所以这就是为什么很多人的文章中都说Springboot的自动装配就是调用@EnableAutoConfiguration注解下的@Import中的AutoConfigurationImportSelector类,主要就是通过这种不断解析注解的方法去调用的
-
将所有解析到的注解的类都注册到BeanDifinitionMap中
-
至此就完成了SpringBoot的自动装配
完整流程(结合源码)
启动类
@SpringBootApplication
public class Test {
public static void main(String[] args) {
SpringApplication.run(Test.class, args);
System.out.println("启动成功");
}
}
SpringApplication的构造方法
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();
// 加载Spring.factories文件,将文件的内容放到缓存对象中,方便后续获取
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
// 设置监听器
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
// 将mainApplicationClass属性设置为当前类Test的Clas对象
this.mainApplicationClass = deduceMainApplicationClass();
}
run方法
public ConfigurableApplicationContext run(String... args) {
// 省略代码
try {
// 准备环境,这里的environment环境包括系统环境,比如jvm的参数等等
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
// 准备Banner,即每次启动项目的时候控制台都会出现一个很大的图像
Banner printedBanner = printBanner(environment);
// 创建上下文对象
context = createApplicationContext();
// 准备上下文对象
prepareContext(context, environment, listeners, applicationArguments, printedBanner);
// 刷新上下文对象
refreshContext(context);
// 省略代码
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, listeners);
throw new IllegalStateException(ex);
}
}
prepareContext()方法
准备上下文对象,将springApplicationArguments对象和springBootBanner对象放入Spring一级缓存singletonObjects中
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
// 省略代码
// 获取Beanfactory对象
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
// 将springApplicationArgusments放到一级缓存中
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
// 将springBootBanner放到一级缓存中
if (printedBanner != null) {
beanFactory.registerSingleton("springBootBanner", printedBanner);
}
// 加载资源,也就是将当前的启动类Test Class对象放到Set中
Set<Object> sources = getAllSources();
// 见下
load(context, sources.toArray(new Object[0]));
// 将上下文加载到监听器中
listeners.contextLoaded(context);
}
load()方法
将当前启动类作为一个BeanDefinition加载到BeanDefinitionMap中,方便后续在进行BeanFactoryPostProcessor调用执行的时候,找到对应的启动类,来完成对应注解的解析工作
private int load(Class<?> source) {
// 判断启动类上有没有@Component注解
if (isComponent(source)) {
// 若有则将当前启动类作为一个BeanDefinition注册到BeanDifinitionMap中
this.annotatedReader.register(source);
return 1;
}
return 0;
}
refreshContext()方法
执行完prepareContext()方法后,调用Spring的刷新容器方法refresh()
private void refreshContext(ConfigurableApplicationContext context) {
// 调用Spring的刷新容器方法
refresh(context);
}
refresh()方法
这个方法相信大家非常熟悉了吧,那完成Springboot自动装配过程是在哪个阶段发生的呢?其实就是在invokeBeanFactoryPostProcessors()方法实现的
// 伪代码,方法在AbstractApplicationContext类中
public void refresh() throws BeansException, IllegalStateException {
// 执行BeanFactory的后置处理器,自动装配中此方法主要是针对ConfigurationClassPostProcessor类的处理
invokeBeanFactoryPostProcessors(beanFactory);
}
invokeBeanFactoryPostProcessors()方法
这里主要就是处理BeanFactory后置处理器,也就是直接或者间接实现BeanFactoryPostProcessor的接口的类,主要调用的是ConfigurationClassPostProcessor中的postProcessBeanDefinitionRegistry()方法
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
// 主要就是这个方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
}
}
}
}
ConfigurationClassPostProcessor类中的processConfigBeanDefinitions()方法
此方法作用就是去解析处理各种注解比如@CompomentScan、@Import等等注解
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
// ...
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
// 获取对应的BeanDifinitionMap中的BeanDefinitionName
String[] candidateNames = registry.getBeanDefinitionNames();
// 创建注解解析器
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
// 进行注解解析
parser.parse(candidates);
} while (!candidates.isEmpty());
// ...
}
ConfigurationClassParser类中的parse()方法
解析注解的入口
public void parse(Set<BeanDefinitionHolder> configCandidates) {
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
if (bd instanceof AnnotatedBeanDefinition) {
// 具体的解析注解的方法
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
}
this.deferredImportSelectorHandler.process();
}
ConfigurationClassParser类中的doProcessConfigurationClass()方法
到达解析注解的最终方法,将解析到的Bean注册到BeanDifinitionMap中
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
// 解析@PropertySource注解
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
else {
logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// 解析@ComponentScan注解
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
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());
}
}
}
}
// 解析@Import注解
processImports(configClass, sourceClass, getImports(sourceClass), true);
// 解析@ImportResource注解
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// 解析@Bean注解
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
return null;
}
AutoConfigurationImportSelector类中的process()方法
这里的作用是读取Spring.factories文件中的内容,将所有的第三方的starter装载到BeanDefinitionMap中
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
// getAutoConfigurationEntry()方法读取Spring.factories文件中的内容入口
AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
.getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
this.autoConfigurationEntries.add(autoConfigurationEntry);
for (String importClassName : autoConfigurationEntry.getConfigurations()) {
this.entries.putIfAbsent(importClassName, annotationMetadata);
}
}
至此,springboot的自动装配就完成了
创作不易,希望大家能够点个赞,也希望大家能帮忙指出问题,一起进步!!!谢谢大家~~