springboot-自动配置
1. 概述
本文，咱们来分享 Spring Boot 自动配置的实现源码。在故事的开始，咱们先来讲两个事情：html
- 自动配置和自动装配的区别？
- Spring Boot 配置的原理
2. 自动配置 V.S 自动装配
在这篇文章的开始，艿艿是有点混淆自动配置和自动装配的概念，后来通过 Google 以后，发现二者是截然不如同的：java
- 自动配置：是 Spring Boot 提供的，实现经过 jar 包的依赖，可以自动配置应用程序。例如说：咱们引入
spring-boot-starter-web以后，就自动引入了 Spring MVC 相关的 jar 包，从而自动配置 Spring MVC 。 - 自动装配：是 Spring 提供的 IoC 注入方式，具体看看 《Spring 教程 —— Beans 自动装配》 文档。
因此，不要和艿艿同样愚蠢的搞错落。git
3. 自动装配原理
胖友能够直接看 《详解 Spring Boot 自动配置机制》 文章的 「2、Spring Boot 自动配置」 小节，艿艿以为写的挺清晰的。github
下面，咱们即开始正式撸具体的代码实现了。web
4. @SpringBootApplication
org.springframework.boot.autoconfigure.@SpringBootApplication 注解，基本咱们的 Spring Boot 应用，必定会去有这样一个注解。而且，经过使用它，不只仅能标记这是一个 Spring Boot 应用，并且可以开启自动配置的功能。这是为何呢？spring
😈
@SpringBootApplication注解，它在spring-boot-autoconfigure模块中。因此，咱们使用 Spring Boot 项目时，若是不想使用自动配置功能，就不用引入它。固然，咱们貌似不太会存在这样的需求，是吧~数组
@SpringBootApplication 是一个组合注解。代码以下：网络
// SpringBootApplication.java |
下面，咱们来逐个看 @SpringBootApplication 上的每一个注解。app
4.1 @Inherited
Java 自带的注解。ide
java.lang.annotation.@Inherited 注解，使用此注解声明出来的自定义注解，在使用此自定义注解时，若是注解在类上面时，子类会自动继承此注解，不然的话，子类不会继承此注解。
这里必定要记住，使用 @Inherited 声明出来的注解，只有在类上使用时才会有效，对方法，属性等其余无效。
不了解的胖友，能够看看 《关于 Java 注解中元注解 Inherited 的使用详解》 文章。
4.2 @SpringBootConfiguration
Spring Boot 自定义的注解
org.springframework.boot.@SpringBootConfiguration 注解，标记这是一个 Spring Boot 配置类。代码以下：
// SpringBootConfiguration.java |
- 能够看到，它上面继承自
@Configuration注解，因此二者功能也一致，能够将当前类内声明的一个或多个以@Bean注解标记的方法的实例归入到 Srping 容器中，而且实例名就是方法名。
4.3 @ComponentScan
Spring 自定义的注解
org.springframework.context.annotation.@ComponentScan 注解，扫描指定路径下的 Component（@Componment、@Configuration、@Service 等等）。
不了解的胖友，能够看看 《Spring：@ComponentScan 使用》 文章。
4.4 @EnableAutoConfiguration
Spring Boot 自定义的注解
org.springframework.boot.autoconfigure.@EnableAutoConfiguration 注解，用于开启自动配置功能，是 spring-boot-autoconfigure 项目最核心的注解。代码以下：
// EnableAutoConfiguration.java |
-
org.springframework.boot.autoconfigure.@AutoConfigurationPackage注解，主要功能自动配置包，它会获取主程序类所在的包路径，并将包路径（包括子包）下的全部组件注册到 Spring IOC 容器中。代码以下：// AutoConfigurationPackage.javaorg.springframework.context.annotation.@Import注解，可用于资源的导入。状况比较多，能够看看 《六、@Import 注解——导入资源》 文章。- AutoConfigurationPackages.Registrar ，有点神奇，这里先不说。胖友最后去看 「6. AutoConfigurationPackages」 小节。
-
@Import(AutoConfigurationImportSelector.class)注解部分，是重头戏的开始。org.springframework.context.annotation.@Import注解，可用于资源的导入。状况比较多，能够看看 《六、@Import 注解——导入资源》 文章。- AutoConfigurationImportSelector ，导入自动配置相关的资源。详细解析，见 「5. AutoConfigurationImportSelector」 小节。
5. AutoConfigurationImportSelector
org.springframework.boot.autoconfigure.AutoConfigurationImportSelector ，实现 DeferredImportSelector、BeanClassLoaderAware、ResourceLoaderAware、BeanFactoryAware、EnvironmentAware、Ordered 接口，处理 @EnableAutoConfiguration 注解的资源导入。
5.1 getCandidateConfigurations
#getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) 方法，得到符合条件的配置类的数组。代码以下：
// AutoConfigurationImportSelector.java |
-
<1>处，调用#getSpringFactoriesLoaderFactoryClass()方法，得到要从META-INF/spring.factories加载的指定类型为 EnableAutoConfiguration 类。代码以下：// AutoConfigurationImportSelector.java
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
return EnableAutoConfiguration.class;
} -
<1>处，调用SpringFactoriesLoader#loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader)方法，加载指定类型 EnableAutoConfiguration 对应的，在META-INF/spring.factories里的类名的数组。看看下图，胖友相信就明白了：
通常来讲，和网络上 Spring Boot 勇于这块的源码解析，咱们就能够结束了。若是单纯是为了了解原理 Spring Boot 自动配置的原理，这里结束也是没问题的。由于，拿到 Configuration 配置类后，后面的就是 Spring Java Config 的事情了。不了解的胖友，能够看看 《Spring 教程 —— 基于 Java 的配置》 文章。
😜 可是（“可是”同窗，你赶忙坐下），具备倒腾精神的艿艿，以为仍是继续瞅瞅 #getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) 方法是怎么被调用的。因此，咱们来看看调用它的方法调用链，以下图所示：
- ① 处，refresh 方法的调用，咱们在 《精尽 Spring Boot 源码分析 —— SpringApplication》 中，SpringApplication 启动时，会调用到该方法。
- ② 处，
#getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes)方法被调用。 -
③ 处，那么此处，就是问题的关键。代码以下：
艿艿：由于我还没特别完整的撸完 Spring Java Annotations 相关的源码，因此下面的部分，咱们更可能是看整个调用过程。😈 刚好，胖友也没看过，哈哈哈哈。
// ConfigurationClassParser#DeferredImportSelectorGroupingHandler.java
private final DeferredImportSelector.Group group;
public Iterable<Group.Entry> getImports() {
for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
this.group.process(deferredImport.getConfigurationClass().getMetadata(),
deferredImport.getImportSelector()); // <1>
}
return this.group.selectImports(); // <2>
}<1>处，调用DeferredImportSelector.Group#process(AnnotationMetadata metadata, DeferredImportSelector selector)方法，处理被@Import注解的注解。<2>处，调用DeferredImportSelector.Group#this.group.selectImports()方法，选择须要导入的。例如：
- 这里，咱们能够看到须要导入的 Configuration 配置类。
- 具体
<1>和<2>处，在 「5.3 AutoConfigurationGroup」 详细解析。
5.2 getImportGroup
#getImportGroup() 方法，得到对应的 Group 实现类。代码以下：
// AutoConfigurationImportSelector.java |
- 关于 AutoConfigurationGroup 类，在 「5.3 AutoConfigurationGroup」 详细解析。
5.3 AutoConfigurationGroup
艿艿：注意，从这里开始后，东西会比较难。由于，涉及的东西会比较多。
AutoConfigurationGroup ，是 AutoConfigurationImportSelector 的内部类，实现 DeferredImportSelector.Group、BeanClassLoaderAware、BeanFactoryAware、ResourceLoaderAware 接口，自动配置的 Group 实现类。
5.3.1 属性
// AutoConfigurationImportSelector#AutoConfigurationGroup.java |
entries属性，AnnotationMetadata 的映射。其中，KEY 为 配置类的全类名。在后续咱们将看到的AutoConfigurationGroup#process(...)方法中，被进行赋值。例如：-
autoConfigurationEntries属性，AutoConfigurationEntry 的数组。-
其中，AutoConfigurationEntry 是 AutoConfigurationImportSelector 的内部类，自动配置的条目。代码以下：
// AutoConfigurationImportSelector#AutoConfigurationEntry.java
protected static class AutoConfigurationEntry {
/**
* 配置类的全类名的数组
*/
private final List<String> configurations;
/**
* 排除的配置类的全类名的数组
*/
private final Set<String> exclusions;
// 省略构造方法和 setting/getting 方法
}- 属性比较简单。
- 在后续咱们将看到的
AutoConfigurationGroup#process(...)方法中，被进行赋值。例如：
-
-
autoConfigurationMetadata属性，自动配置的元数据（Metadata）。-
经过
#getAutoConfigurationMetadata()方法，会初始化该属性。代码以下：// AutoConfigurationImportSelector#AutoConfigurationGroup.java
private AutoConfigurationMetadata getAutoConfigurationMetadata() {
// 不存在，则进行加载
if (this.autoConfigurationMetadata == null) {
this.autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
}
// 存在，则直接返回
return this.autoConfigurationMetadata;
}- 关于 AutoConfigurationMetadataLoader 类，咱们先不去愁。避免，咱们调试的太过深刻。TODO 后续在补充下。
- 返回的类型是 PropertiesAutoConfigurationMetadata ，比较简单，胖友点击 传送门 瞅一眼便可。
- 以下是一个返回值的示例：
- 可能胖友会有点懵逼，这么多，而且 KEY / VALUE 结果看不懂？不要方，咱们简单来讲下 CouchbaseReactiveRepositoriesAutoConfiguration 配置类。若是它生效，须要 classpath 下有 Bucket、ReactiveCouchbaseRepository、Flux 三个类，因此红线那个条目，对应的就是 CouchbaseReactiveRepositoriesAutoConfiguration 类上的
@ConditionalOnClass({ Bucket.class, ReactiveCouchbaseRepository.class, Flux.class })注解部分。
- 可能胖友会有点懵逼，这么多，而且 KEY / VALUE 结果看不懂？不要方，咱们简单来讲下 CouchbaseReactiveRepositoriesAutoConfiguration 配置类。若是它生效，须要 classpath 下有 Bucket、ReactiveCouchbaseRepository、Flux 三个类，因此红线那个条目，对应的就是 CouchbaseReactiveRepositoriesAutoConfiguration 类上的
- 因此，
autoConfigurationMetadata属性，用途就是制定配置类（Configuration）的生效条件（Condition）。
-
5.3.2 process
#process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) 方法，进行处理。代码以下：
// AutoConfigurationImportSelector#AutoConfigurationGroup.java |
annotationMetadata参数，通常来讲是被@SpringBootApplication注解的元数据。由于，@SpringBootApplication组合了@EnableAutoConfiguration注解。deferredImportSelector参数，@EnableAutoConfiguration注解的定义的@Import的类，即 AutoConfigurationImportSelector 对象。<1>处，调用AutoConfigurationImportSelector#getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata)方法，得到 AutoConfigurationEntry 对象。详细解析，见 「5.4 AutoConfigurationEntry」 。由于这块比较重要，因此先跳过去瞅瞅。<2>处，添加到autoConfigurationEntries中。<3>处，添加到entries中。
5.3.3 selectImports
#selectImports() 方法，得到要引入的配置类。代码以下：
// AutoConfigurationImportSelector#AutoConfigurationGroup.java |
<1>处，若是为空，则返回空数组。<2.1>、<2.2>、<2.3>处，得到要引入的配置类集合。😈 比较奇怪的是，上面已经作过一次移除的处理，这里又作一次。不过，没多大关系，能够先无视。-
<3>处，处理，返回结果。-
<3.1>处，调用#sortAutoConfigurations(Set<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata)方法，排序。代码以下：// AutoConfigurationImportSelector#AutoConfigurationGroup.java
private List<String> sortAutoConfigurations(Set<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata) {
return new AutoConfigurationSorter(getMetadataReaderFactory(), autoConfigurationMetadata).getInPriorityOrder(configurations);
}- 具体的排序逻辑，胖友本身看。实际上，仍是涉及哪些，例如说
@Order注解。
- 具体的排序逻辑，胖友本身看。实际上，仍是涉及哪些，例如说
<3.2>处，建立 Entry 对象。<3.3>处，转换成 List 。结果以下图：
-
艿艿：略微有点艰难的过程。不过回过头来，其实也没啥特别复杂的逻辑。是不，胖友~
5.4 getAutoConfigurationEntry
艿艿：这是一个关键方法。由于会调用到，咱们会在 「5.1 getCandidateConfigurations」 的方法。
#getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) 方法，得到 AutoConfigurationEntry 对象。代码以下：
// AutoConfigurationImportSelector.java |
这里每一步都是细节的方法，因此会每个方法，都会是引导到对应的小节的方法。
虽然有点长，可是很不复杂。简单的来讲，加载符合条件的配置类们，而后移除须要排除（exclusion）的。
<1>处，调用#isEnabled(AnnotationMetadata metadata)方法，判断是否开启。如未开启，返回空数组。详细解析，见 「5.4.1 isEnabled」 。<2>处，调用#getAttributes(AnnotationMetadata metadata)方法，得到注解的属性。详细解析，见 「5.4.2 getAttributes」 。-
【重要】
<3>处，调用#getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes)方法，得到符合条件的配置类的数组。嘻嘻，到达此书以后，整个细节是否是就串起来了!
-
<3.1>处，调用#removeDuplicates(List<T> list)方法，移除重复的配置类。代码以下：// AutoConfigurationImportSelector.java
protected final <T> List<T> removeDuplicates(List<T> list) {
return new ArrayList<>(new LinkedHashSet<>(list));
}- 简单粗暴
-
-
<4>处，调用#getExclusions(AnnotationMetadata metadata, AnnotationAttributes attributes)方法，得到须要排除的配置类。详细解析，见 「5.4.3 getExclusions」 。<4.1>处，调用#checkExcludedClasses(List<String> configurations, Set<String> exclusions)方法，校验排除的配置类是否合法。详细解析，见 「5.4.4 checkExcludedClasses」 。<4.2>处，从configurations中，移除须要排除的配置类。
-
<5>处，调用#filter(List<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata)方法，根据条件（Condition），过滤掉不符合条件的配置类。详细解析，见 《精尽 Spring Boot 源码分析 —— Condition》 文章。 <6>处，调用#fireAutoConfigurationImportEvents(List<String> configurations, Set<String> exclusions)方法，触发自动配置类引入完成的事件。详细解析，见 「5.4.5 fireAutoConfigurationImportEvents」 。<7>处，建立 AutoConfigurationEntry 对象。
整个 「5.4 getAutoConfigurationEntry」 看完后，胖友请跳回 「5.3.3 selectImports」 。
5.4.1 isEnabled
#isEnabled(AnnotationMetadata metadata) 方法，判断是否开启自动配置。代码以下：
// AutoConfigurationImportSelector.java |
5.4.2 getAttributes
#getAttributes(AnnotationMetadata metadata) 方法，得到注解的属性。代码以下：
// AutoConfigurationImportSelector.java |
- 注意，此处
getAnnotationClass().getName()返回的是@EnableAutoConfiguration注解，因此这里返回的注解属性，只能是exclude和excludeName这两个。 -
举个例子，假设 Spring 应用上的注解以下：
- 返回的结果，以下图：
- 返回的结果，以下图：
5.4.3 getExclusions
#getExclusions(AnnotationMetadata metadata, AnnotationAttributes attributes) 方法，得到须要排除的配置类。代码以下：
// AutoConfigurationImportSelector.java |
- 一共有三种方式，配置排除属性。
-
该方法会调用以下的方法，比较简单，胖友本身瞅瞅。
// AutoConfigurationImportSelector.java
private List<String> getExcludeAutoConfigurationsProperty() {
// 通常来讲，会走这块的逻辑
if (getEnvironment() instanceof ConfigurableEnvironment) {
Binder binder = Binder.get(getEnvironment());
return binder.bind(PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE, String[].class).map(Arrays::asList).orElse(Collections.emptyList());
}
String[] excludes = getEnvironment().getProperty(PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE, String[].class);
return (excludes != null) ? Arrays.asList(excludes) : Collections.emptyList();
}
protected final List<String> asList(AnnotationAttributes attributes, String name) {
String[] value = attributes.getStringArray(name);
return Arrays.asList(value);
}
5.4.4 checkExcludedClasses
#checkExcludedClasses(List<String> configurations, Set<String> exclusions) 方法，校验排除的配置类是否合法。代码以下：
// AutoConfigurationImportSelector.java |
- 不合法的定义，
exclusions存在于 classpath 中，可是不存在configurations。这样作的目的是，若是不存在的，就不要去排除啦！ - 代码比较简单，胖友本身瞅瞅便可。
5.4.5 fireAutoConfigurationImportEvents
#fireAutoConfigurationImportEvents(List<String> configurations, Set<String> exclusions) 方法，触发自动配置类引入完成的事件。代码以下：
// AutoConfigurationImportSelector.java |
<1>处，调用#getAutoConfigurationImportListeners()方法，加载指定类型 AutoConfigurationImportListener 对应的，在META-INF/spring.factories里的类名的数组。例如：<2>处，建立 AutoConfigurationImportEvent 事件。-
<3>处，遍历 AutoConfigurationImportListener 监听器们，逐个通知。-
<3.1>处，调用#invokeAwareMethods(Object instance)方法，设置 AutoConfigurationImportListener 的属性。代码以下：// AutoConfigurationImportSelector.java
private void invokeAwareMethods(Object instance) {
// 各类 Aware 属性的注入
if (instance instanceof Aware) {
if (instance instanceof BeanClassLoaderAware) {
((BeanClassLoaderAware) instance).setBeanClassLoader(this.beanClassLoader);
}
if (instance instanceof BeanFactoryAware) {
((BeanFactoryAware) instance).setBeanFactory(this.beanFactory);
}
if (instance instanceof EnvironmentAware) {
((EnvironmentAware) instance).setEnvironment(this.environment);
}
if (instance instanceof ResourceLoaderAware) {
((ResourceLoaderAware) instance).setResourceLoader(this.resourceLoader);
}
}
}- 各类 Aware 属性的注入。
-
<3.2>处，调用AutoConfigurationImportListener#onAutoConfigurationImportEvent(event)方法，通知监听器。目前只有一个 ConditionEvaluationReportAutoConfigurationImportListener 监听器，没啥逻辑，有兴趣本身看哈。
-
6. AutoConfigurationPackages
org.springframework.boot.autoconfigure.AutoConfigurationPackages ，自动配置所在的包名。可能这么解释有点怪怪的，咱们来看下官方注释：
Class for storing auto-configuration packages for reference later (e.g. by JPA entity scanner). |
- 简单来讲，就是将使用
@AutoConfigurationPackage注解的类所在的包（package），注册成一个 Spring IoC 容器中的 Bean 。酱紫，后续有其它模块须要使用，就能够经过得到该 Bean ，从而得到所在的包。例如说，JPA 模块，须要使用到。
是否是有点神奇，艿艿也以为。
6.1 Registrar
Registrar ，是 AutoConfigurationPackages 的内部类，实现 ImportBeanDefinitionRegistrar、DeterminableImports 接口，注册器，用于处理 @AutoConfigurationPackage 注解。代码以下：
// AutoConfigurationPackages#Registrar.java |
-
PackageImport 是 AutoConfigurationPackages 的内部类，用于得到包名。代码以下：
// AutoConfigurationPackages#Registrar.java
private static final class PackageImport {
/**
* 包名
*/
private final String packageName;
PackageImport(AnnotationMetadata metadata) {
this.packageName = ClassUtils.getPackageName(metadata.getClassName());
}
public String getPackageName() {
return this.packageName;
}
- 以下是一个示例：
- 以下是一个示例：
<X>处，调用#register(BeanDefinitionRegistry registry, String... packageNames)方法，注册一个用于存储报名（package）的 Bean 到 Spring IoC 容器中。详细解析，见 「6.2 register」 。
6.2 register
#register(BeanDefinitionRegistry registry, String... packageNames) 方法，注册一个用于存储报名（package）的 Bean 到 Spring IoC 容器中。代码以下：
// AutoConfigurationPackages.java |
-
注册的
BEAN的类型，为 BasePackages 类型。它是 AutoConfigurationPackages 的内部类。代码以下：// AutoConfigurationPackages#BasePackages.java
static final class BasePackages {
private final List<String> packages;
private boolean loggedBasePackageInfo;
BasePackages(String... names) {
List<String> packages = new ArrayList<>();
for (String name : names) {
if (StringUtils.hasText(name)) {
packages.add(name);
}
}
this.packages = packages;
}
public List<String> get() {
if (!this.loggedBasePackageInfo) {
if (this.packages.isEmpty()) {
if (logger.isWarnEnabled()) {
logger.warn("@EnableAutoConfiguration was declared on a class "
+ "in the default package. Automatic @Repository and "
+ "@Entity scanning is not enabled.");
}
} else {
if (logger.isDebugEnabled()) {
String packageNames = StringUtils
.collectionToCommaDelimitedString(this.packages);
logger.debug("@EnableAutoConfiguration was declared on a class "
+ "in the package '" + packageNames
+ "'. Automatic @Repository and @Entity scanning is "
+ "enabled.");
}
}
this.loggedBasePackageInfo = true;
}
return this.packages;
}
}- 就是一个有
packages属性的封装类。
- 就是一个有
<1>处，若是已经存在该BEAN，则修改其包（package）属性。而合并package的逻辑，经过#addBasePackages(ConstructorArgumentValues constructorArguments, String[] packageNames)方法，进行实现。代码以下：// AutoConfigurationPackages.java
private static String[] addBasePackages(ConstructorArgumentValues constructorArguments, String[] packageNames) {
// 得到已存在的
String[] existing = (String[]) constructorArguments.getIndexedArgumentValue(0, String[].class).getValue();
// 进行合并
Set<String> merged = new LinkedHashSet<>();
merged.addAll(Arrays.asList(existing));
merged.addAll(Arrays.asList(packageNames));
return StringUtils.toStringArray(merged);
}
<2>处，若是不存在该BEAN，则建立一个Bean，并进行注册。
6.3 has
#has(BeanFactory beanFactory) 方法，判断是否存在该 BEAN 在传入的容器中。代码以下：
// AutoConfigurationPackages.java |
6.4 get
#get(BeanFactory beanFactory) 方法，得到 BEAN 。代码以下：
// AutoConfigurationPackages.java |
- 1. SpringBoot自动配置
- 2. SpringBoot-自动配置
- 3. springboot——自动配置
- 4. SpringBoot 自动配置
- 5. springboot自动配置
- 6. SpringBoot自动配置原理
- 7. springboot自动配置解析
- 8. SpringBoot 自动配置原理
- 9. springboot自动配置流程
- 10. SpringBoot高级——————自动配置
- 更多相关文章...
- • Spring自动装配Bean - Spring教程
- • IP地址分配（静态分配+动态分配+零配置） - TCP/IP教程
- • IDEA下SpringBoot工程配置文件没有提示
- • SpringBoot中properties文件不能自动提示解决方法
-
每一个你不满意的现在，都有一个你没有努力的曾经。