目录
一、简介
1)、@SpringBootConfiguration
2)、@ComponentScan
3)、@EnableAutoConfiguration
二、@AutoConfigurationPackage
三、@Import(AutoConfigurationImportSelector.class)
1)、AutoConfigurationImportSelector介绍
2)、自动配置流程
2-1)、ConfigurationClassParser#parse()
2-2)、this.deferredImportSelectorHandler.process()
2-2-1)、第一步：register()
2-2-2)、第二步：processGroupImports()
本篇源码基于spring-boot-2.1.0.RELEASE版本进行分析，各个版本可能存在一些差别。
一、简介
SpringBoot的启动从main()方法开始：
@SpringBootApplication
public class SampleTomcatApplication {
public static void main(String[] args) {
SpringApplication.run(SampleTomcatApplication.class, args);
}
}在主启动类上，我们只需要加上@SpringBootApplication注解，就能成功启动springboot应用了，那么我们就从注解入手，看下它是如何帮我们配置好所需要的一些环境的。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// @SpringBootConfiguration内部使用@Configuration修饰，标记启动类是一个Spring的配置类
@SpringBootConfiguration
// @EnableAutoConfiguration: 实现自动装配的核心注解. 内部包含两个注解：@AutoConfigurationPackage + @Import(AutoConfigurationImportSelector.class)
@EnableAutoConfiguration
// 包扫描：扫描启动类所在的包以及子包所有Bean组件并注册到IOC容器中
@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
// SpringBoot项目启动的核心注解
// @SpringBootApplication = @SpringBootConfiguration + @EnableAutoConfiguration + @ComponentScan
public @interface SpringBootApplication {
/**
* Exclude specific auto-configuration classes such that they will never be applied.
* @return the classes to exclude
*/
// 等同于EnableAutoConfiguration注解的exclude属性
@AliasFor(annotation = EnableAutoConfiguration.class)
Class<?>[] exclude() default {};
/**
* Exclude specific auto-configuration class names such that they will never be
* applied.
* @return the class names to exclude
* @since 1.3.0
*/
// 等同于EnableAutoConfiguration注解的excludeName属性
@AliasFor(annotation = EnableAutoConfiguration.class)
String[] excludeName() default {};
/**
* Base packages to scan for annotated components. Use {@link #scanBasePackageClasses}
* for a type-safe alternative to String-based package names.
* @return base packages to scan
* @since 1.3.0
*/
// 等同于ComponentScan注解的basePackages属性
@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
String[] scanBasePackages() default {};
/**
* Type-safe alternative to {@link #scanBasePackages} for specifying the packages to
* scan for annotated components. The package of each class specified will be scanned.
* <p>
* Consider creating a special no-op marker class or interface in each package that
* serves no purpose other than being referenced by this attribute.
* @return base packages to scan
* @since 1.3.0
*/
// 等同于ComponentScan注解的basePackageClasses属性
@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
Class<?>[] scanBasePackageClasses() default {};
}@SpringBootApplication 使用三个注解修饰：
1)、@SpringBootConfiguration
标记启动类是一个Spring的配置类。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
// 相当于@SpringBootConfiguration就是@Configuration
public @interface SpringBootConfiguration {
}2)、@ComponentScan
扫描启动类所在的包以及子包所有Bean组件并注册到IOC容器中。
3)、@EnableAutoConfiguration
实现自动装配的核心注解，内部包含两个注解：@AutoConfigurationPackage + @Import(AutoConfigurationImportSelector.class)。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// 自动配置包
@AutoConfigurationPackage
// 使用@Import注解导入AutoConfigurationImportSelector类，实现了ImportSelector接口，重写了selectImports()方法，帮助我们返回所有需要被注册为bean的类全限定类名的数组集合
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
/**
* 排除特定的自动配置类，使它们永远不会被应用
* Exclude specific auto-configuration classes such that they will never be applied.
* @return the classes to exclude
*/
Class<?>[] exclude() default {};
/**
* 排除特定的自动配置类名称，使其永远不会被应用
* Exclude specific auto-configuration class names such that they will never be
* applied.
* @return the class names to exclude
* @since 1.3.0
*/
String[] excludeName() default {};
}springboot的自动装配就是依靠@EnableAutoConfiguration这个注解实现的，而@EnableAutoConfiguration又是由下面两部分组成：
1、@AutoConfigurationPackage
2、@Import(AutoConfigurationImportSelector.class)
二、@AutoConfigurationPackage
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// 向容器中导入了AutoConfigurationPackages.Registrar组件
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
}可以看到，@AutoConfigurationPackage注解的功能是由@Import注解实现的，它是Spring框架的底层注解，它的作用就是给容器中导入某个组件类AutoConfigurationPackages.Registrar，我们看下这是个什么组件？
@AutoConfigurationPackage注解的作用是将添加该注解的类所在的package作为自动配置package进行管理。也就是说当SpringBoot应用启动时默认会将启动类所在的package作为自动配置的package，这样主程序类所在包及所有子包下的组件就会被扫描到spring容器中。
// 实现了ImportBeanDefinitionRegistrar、DeterminableImports接口，重写了registerBeanDefinitions()、determineImports()方法
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
// 注册bean定义
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
register(registry, new PackageImport(metadata).getPackageName());
}
// 返回一组需要注入的对象
@Override
public Set<Object> determineImports(AnnotationMetadata metadata) {
return Collections.singleton(new PackageImport(metadata));
}
}AutoConfigurationPackages.Registrar实现了ImportBeanDefinitionRegistrar，并重写了registerBeanDefinitions()注册bean定义信息的方法，这样在刷新IOC容器，即执行refresh()方法，在invokeBeanFactoryPostProcessors(beanFactory)这一步，会执行BeanDefinitionRegistryPostProcessor这个后置处理器的增强方法时，执行loadBeanDefinitions()加载bean定义信息，就会扫描到AutoConfigurationPackages.Registrar这个类，然后就会回调AutoConfigurationPackages.Registrar中的registerBeanDefinitions()方法：
register(registry, new PackageImport(metadata).getPackageName());
// 注册自动包规则的bean定义信息
public static void register(BeanDefinitionRegistry registry, String... packageNames) { // sample.tomcat
// 判断bean定义信息注册表中是否存在org.springframework.boot.autoconfigure.AutoConfigurationPackages
if (registry.containsBeanDefinition(BEAN)) {
// 如果该bean已经注册，则将要注册包名称添加进去
BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
ConstructorArgumentValues constructorArguments = beanDefinition
.getConstructorArgumentValues();
constructorArguments.addIndexedArgumentValue(0,
addBasePackages(constructorArguments, packageNames));
}
else { // 如果该bean尚未注册，则注册该bean，参数中提供的包名称会被设置到bean定义中去
// 创建简单类型的bean定义信息GenericBeanDefinition
GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
// bean类 : AutoConfigurationPackages$BasePackages
beanDefinition.setBeanClass(BasePackages.class);
// bean实例构造函数第一个参数 : 被使用类所在包名 (比如@SpringBootApplication注解所在类的包名)
beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0,
packageNames);
// bean 角色 : 基础设施
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
// 注册bean定义信息, bean名称 : org.springframework.boot.autoconfigure.AutoConfigurationPackages
registry.registerBeanDefinition(BEAN, beanDefinition);
}
}在本例中，SampleTomcatApplication在sample.tomcat包中，所以自动配置package为sample.tomcat。
@AutoConfigurationPackage和@ComponentScan的作用有什么区别？
- @AutoConfigurationPackage ：是为了给组件开发者使用的，组件开发者在一个路径下面有多个自动配置的类想加载，这个注解就不用对每个类单独添加 @Import 了，直接引入包路径更方便。
- @ComponentScan ：是为了用组件的开发者准备的，方便你对包路径进行自定义，比如你的一些 Bean 跟 SpringBootApplication 不在一个路径下面，或者多个不同路径下面，这个就起到作用了。
以上面的示例来说，其实@AutoConfigurationPackage就相当于在启动类加上@ComponentScan(basePackages = "sample.tomcat")。
三、@Import(AutoConfigurationImportSelector.class)
1)、AutoConfigurationImportSelector介绍
@EnableAutoConfiguration注解通过@Import(AutoConfigurationImportSelector.class)向容器中导入了AutoConfigurationImportSelector组件，它实现了DeferredImportSelector，并间接实现了ImportSelector接口，重写了selectImports()方法，帮助我们返回所有需要被注册为bean的类全限定类名的数组集合。
public class AutoConfigurationImportSelector
implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware,
BeanFactoryAware, EnvironmentAware, Ordered {
//...
}我们先来看下AutoConfigurationImportSelector的类图：
AutoConfigurationImportSelector实现的是DeferredImportSelector接口，而不是ImportSelector接口，两者的执行时间是不一样的：
- 1、ImportSelector实例的selectImports方法的执行时机，是在@Configguration注解中的其他逻辑被处理之前，所谓的其他逻辑，包括对@ImportResource、@Bean这些注解的处理；
- 2、DeferredImportSelector实例的selectImports方法的执行时机，是在@Configguration注解中的其他逻辑被处理完毕之后，所谓的其他逻辑，包括对@ImportResource、@Bean这些注解的处理；
2)、自动配置流程
前面介绍到，AutoConfigurationImportSelector实现的是DeferredImportSelector接口，那么下面我们来看看它在哪里发挥作用的。
回到启动类的main()方法：
SpringApplication.run(SampleTomcatApplication.class, args);执行run()方法：
// 运行 Spring 应用程序，创建并刷新一个新的ApplicationContext
public ConfigurableApplicationContext run(String... args) {
// 创建一个任务执行观察器,用于统计run启动过程花了多少时间
StopWatch stopWatch = new StopWatch();
// 记录开始时间
stopWatch.start();
ConfigurableApplicationContext context = null;
// exceptionReporters集合用来存储异常报告器，用来报告SpringBoot启动过程的异常
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
// 设置了一个名为java.awt.headless的系统属性, 其实是想设置该应用程序,即使没有检测到显示器,也允许其启动. 对于服务器来说,是不需要显示器的,所以要这样设置.
configureHeadlessProperty();
// 从spring.factories配置文件中加载到EventPublishingRunListener对象并赋值给SpringApplicationRunListeners
// EventPublishingRunListener对象主要用来发布SpringBoot启动过程中内置的一些生命周期事件，标志每个不同启动阶段
SpringApplicationRunListeners listeners = getRunListeners(args);
// 发布启动事件
listeners.starting();
try {
// 创建ApplicationArguments对象，封装了args参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 准备环境，包括系统变量、环境变量、命令行参数、默认变量等
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
// 配置需要忽略的BeanInfo信息
configureIgnoreBeanInfo(environment);
// 启动时控制台打印Banner
Banner printedBanner = printBanner(environment);
// 根据不同类型创建不同类型的spring容器ApplicationContext应用程序上下文
context = createApplicationContext();
// 加载spring.factories配置文件配置的异常报告器
exceptionReporters = getSpringFactoriesInstances(
SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
// 准备上下文，刷新容器前的一些操作
prepareContext(context, environment, listeners, applicationArguments, printedBanner);
// 刷新应用上下文。完成Spring IOC容器的初始化
refreshContext(context);
// 在刷新上下文后调用的钩子，这个方法是一个模板方法
afterRefresh(context, applicationArguments);
// 停止记录执行时间
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
// 事件广播，启动完成了
listeners.started(context);
// 执行ApplicationRunner、CommandLineRunner的run方法，实现spring容器启动成功后需要执行的一些逻辑
callRunners(context, applicationArguments);
} catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, listeners);
throw new IllegalStateException(ex);
}
try {
listeners.running(context);
} catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, null);
throw new IllegalStateException(ex);
}
return context;
}上述代码是springboot应用启动的核心流程，我们重点关注refreshContext(context)，也就是刷新Spring的IOC容器方法，自动配置就是在里面实现的。
refreshContext()方法实际上是调用org.springframework.context.support.AbstractApplicationContext#refresh，这个方法是IOC容器刷新的核心方法，主要包括12个步骤：
- a、prepareRefresh()：容器刷新前的一些预处理工作；
- b、obtainFreshBeanFactory()：创建DefaultListableBeanFactory工厂，给bean工厂设置一些属性，加载配置文件信息，封装成bean定义信息；
- c、prepareBeanFactory(beanFactory)：设置bean工厂的一些属性，如添加一些BeanPostProcessor增强器等
- d、postProcessBeanFactory(beanFactory)：模板方法，留给子类扩展实现；
- e、invokeBeanFactoryPostProcessors(beanFactory)：执行BeanFactoryPostProcessor的postProcessBeanFactory()增强方法；
- f、registerBeanPostProcessors(beanFactory)：注册BeanPostProcessor增强器，注意这里只是注册，真正是在初始化阶段的前后执行；
- g、initMessageSource()：初始化MessageSource，国际化处理；
- h、initApplicationEventMulticaster()：初始化事件多播器；
- i、onRefresh()：模板方法，留给子类扩展实现；
- j、registerListeners()：注册一些监听器；
- k、finishBeanFactoryInitialization(beanFactory)：完成非懒加载的单例bean对象的实例化，包括反射创建bean对象、属性填充、循环依赖的处理、bean的初始化等等；
- l、finishRefresh()：容器刷新完成之后的一些处理工作；
重点关注上述的第五步：invokeBeanFactoryPostProcessors(beanFactory)：执行BeanFactoryPostProcessor的postProcessBeanFactory()增强方法；这一步会执行invokeBeanDefinitionRegistryPostProcessors()方法，然后执行BeanDefinitionRegistryPostProcessor后置处理器的postProcessBeanDefinitionRegistry()增强方法。
其中就包含了ConfigurationClassPostProcessor的处理，加载bean定义信息、ConfigurationClassParser解析自动配置相关的类。
调用栈如下：
org.springframework.context.annotation.ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry(ConfigurationClassPostProcessor.java:232)
org.springframework.context.support.PostProcessorRegistrationDelegate.invokeBeanDefinitionRegistryPostProcessors(PostProcessorRegistrationDelegate.java:275)
org.springframework.context.support.PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(PostProcessorRegistrationDelegate.java:95)
org.springframework.context.support.AbstractApplicationContext.invokeBeanFactoryPostProcessors(AbstractApplicationContext.java:691)
org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:528)BeanDefinitionRegistryPostProcessor主要完成对@Configuration注解的处理，类图如下：
我们查看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);
}
if (this.factoriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + registry);
}
this.registriesPostProcessed.add(registryId);
processConfigBeanDefinitions(registry);
}在processConfigBeanDefinitions(registry)中通过ConfigurationClassParser#parse()方法解析bean定义信息：
查看ConfigurationClassParser#parse()方法：
parse()方法主要包括两个步骤：
2-1)、ConfigurationClassParser#parse()
主要是调用ConfigurationClassParser#processConfigurationClass来完成解析配置类：
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName));
}真正解析配置类是在ConfigurationClassParser#doProcessConfigurationClass()方法，这里涉及解析很多自动配置相关的注解，如@PropertySource、@ComponentScan、@Import、@ImportResource等。
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
processMemberClasses(configClass, sourceClass);
}
// Process any @PropertySource annotations
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");
}
}
// 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
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());
}
}
}
}
// Process any @Import annotations
processImports(configClass, sourceClass, getImports(sourceClass), true);
// Process any @ImportResource annotations
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);
}
}
// Process individual @Bean methods
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
processInterfaces(configClass, sourceClass);
// Process superclass, if any
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") &&
!this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse
return sourceClass.getSuperClass();
}
}
// No superclass -> processing is complete
return null;
}
自动配置注解的@Import就是在这里解析的。查看ConfigurationClassParser#processImports()，看下具体是如何解析@Import注解的：
查看源码可知，如果@Import导入的是DeferredImportSelector类型，则会将selector先保存到deferredImportSelectorHandler中，并不会马上执行ImportSelector的selectImports()方法，等到所有的注解都解析完成后，再执行；而非DeferredImportSelector类型，则直接调用ImportSelector的selectImports()方法，然后注入对应的Bean对象；
org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set<org.springframework.beans.factory.config.BeanDefinitionHolder>)方法解析完注解bean定义信息后，才会执行延迟ImportSelector的bean导入，即调用this.deferredImportSelectorHandler.process()。
这里也印证了AutoConfigurationImportSelector实现的DeferredImportSelector的执行时机，是在@Configguration注解中的其他逻辑被处理完毕之后，包括对@ImportResource、@Bean这些注解的处理。
2-2)、this.deferredImportSelectorHandler.process()
回到org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set<org.springframework.beans.factory.config.BeanDefinitionHolder>)方法的最后一行：
this.deferredImportSelectorHandler.process();public void process() {
// 获取到上一步暂存在deferredImportSelectors中的ImportSelector
List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
this.deferredImportSelectors = null;
try {
if (deferredImports != null) {
// 创建延迟ImportSelector的分组处理器，内部是分组的
DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
// 排序
deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
// 第一步：register()
deferredImports.forEach(handler::register);
// 第二步：processGroupImports()
handler.processGroupImports();
}
}
finally {
this.deferredImportSelectors = new ArrayList<>();
}
}下面详细分析两个重要步骤。
2-2-1)、第一步：register()
register()方法主要作用是注册分组，DeferredImportSelectorGroupingHandler根据Group来分组，用于区分不同的ImportSelector。
- 1、groupings： key：组类型（在这里 AutoConfigurationGroup） value：组；
- 2、configurationClasses：key：配置类的注解属性 value：配置类信息；
2-2-2)、第二步：processGroupImports()
看下grouping.getImports()。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();
}
getImports()处理包括两步：
2-2-2-1)、process()方法
AutoConfigurationImportSelector内部定义了AutoConfigurationGroup，它实现了DeferredImportSelector.Group接口，并重写了process()和selectImports()方法。
所以，这里就会执行的是重写后的AutoConfigurationImportSelector.AutoConfigurationGroup#process()方法：
// 这里用来处理自动配置类，比如过滤掉不符合匹配条件的自动配置类
@Override
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()));
// 自动装配的方法入口
// 调用getAutoConfigurationEntry()方法得到自动配置类并封装成autoConfigurationEntry对象
AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
.getAutoConfigurationEntry(getAutoConfigurationMetadata(),
annotationMetadata);
// 将封装了自动配置类的autoConfigurationEntry对象装进autoConfigurationEntries集合
this.autoConfigurationEntries.add(autoConfigurationEntry);
// 遍历所有自动配置类
for (String importClassName : autoConfigurationEntry.getConfigurations()) {
// 将符合条件的自动配置类存入到map中：Map<String, AnnotationMetadata> entries
this.entries.putIfAbsent(importClassName, annotationMetadata);
}
}
AutoConfigurationImportSelector#getAutoConfigurationEntry()方法，获取符合条件的自动配置类，避免加载不必要的自动配置类从而造成内存浪费。
// 获取符合条件的自动配置类，避免加载不必要的自动配置类从而造成内存浪费
protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
// 再次判断是否开启自动配置功能，判断是否有配置spring.boot.enableautoconfiguration属性，默认为true。
if (!isEnabled(annotationMetadata)) {
// 未开启自动配置，直接返回{}
return EMPTY_ENTRY;
}
// 获取@EnableAutoConfiguration注解的 exclude 和 excludeName 属性
AnnotationAttributes attributes = getAttributes(annotationMetadata);
// 获取META-INF/spring.factories文件配置的所有自动配置类，实际上是通过SpringFactoriesLoader.loadFactoryNames()获取
List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
// 删除重复的自动配置类，实际上就是将List包装成LinkedHashSet去重
configurations = removeDuplicates(configurations);
// 获取到需要排除自动装配的类、类名称，以及配置文件中（属性名：spring.autoconfigure.exclude）配置的类
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
// 检查configurations中哪些是需要排除的
checkExcludedClasses(configurations, exclusions);
// 真正从候选自动配置类集合中移除掉需要排除的那些配置类
configurations.removeAll(exclusions);
// 执行AutoConfigurationImportFilter过滤器match方法判断是否符合@ConditionalOnBean,@ConditionalOnClass或@ConditionalOnWebApplication，循环所有的候选的自动配置组件，判断有没有哪些组件不符合条件的，将它们排除掉
configurations = filter(configurations, autoConfigurationMetadata);
// 获取了符合条件的自动配置类后，触发AutoConfigurationImportEvent事件，目的是告诉ConditionEvaluationReport条件评估报告器对象来记录符合条件的自动配置类
fireAutoConfigurationImportEvents(configurations, exclusions);
// 最终的返回的结果，封装成AutoConfigurationEntry
return new AutoConfigurationEntry(configurations, exclusions);
}
AutoConfigurationImportSelector#getCandidateConfigurations 获取候选的自动配置类。
实际上是通过类加载器加载"META-INF/spring.factories"文件中EnableAutoConfiguration对应的自动配置类全类名。
public Iterable<Entry> selectImports() {
if (this.autoConfigurationEntries.isEmpty()) {
return Collections.emptyList();
}
// 获取所有要排除的自动配置类
Set<String> allExclusions = this.autoConfigurationEntries.stream()
.map(AutoConfigurationEntry::getExclusions)
.flatMap(Collection::stream).collect(Collectors.toSet());
// 获取经过滤后所有符合条件的自动配置类
Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
.map(AutoConfigurationEntry::getConfigurations)
.flatMap(Collection::stream)
.collect(Collectors.toCollection(LinkedHashSet::new));
// 删除需要排除的那些自动配置类
processedConfigurations.removeAll(allExclusions);
// 自动配置类排序
return sortAutoConfigurations(processedConfigurations,
getAutoConfigurationMetadata())
.stream()
.map((importClassName) -> new Entry(
this.entries.get(importClassName), importClassName))
.collect(Collectors.toList());
}自动配置的类全类名拿到后，执行selectImports()。
2-2-2-2)、selectImports()方法
获取所有要排除的自动配置类，然后删除不符合条件的那些自动配置类，最后做了一下排序。
至此，getImports()方法执行结束，然后遍历所有获取到的自动配置类的全限定类名，挨个调用processImports()方法注入bean。
我们回到org.springframework.context.annotation.ConfigurationClassParser#processImports()方法：
调用addImportBeanDefinitionRegistrar()方法将bean定义注册到importBeanDefinitionRegistrars中，最后通过ImportBeanDefinitionRegistrar#registerBeanDefinitions()方法注册对应的bean。
我们看org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions的如下代码，parse()方法前面已经分析完成了，获取到了自动配置的bean的定义信息，接下来会执行：this.reader.loadBeanDefinitions(configClasses);加载bean定义信息，注册bean到spring容器中。
到这里，SpringBoot的自动配置原理就分析完了。
