SpringBoot自动配置@EnableAutoConfiguration过程示例
作者：福
自动配置vs自动装配
Spring有两个名字听起来相似的概念：一个是自动装配，一个是自动配置。他们两个只是听起来相似，实际根本不同。自动装配是autowire，自动配置是autoconfiguration，他们之间没有任何关系，概念也相差甚远。
Springboot的自动配置通过@EnableAutoConfiguration注解实现，@EnableAutoConfiguration是Springboot的注解，通过@EnableAutoConfiguration注解，Springboot实现了“约定大于配置”：系统猜测你需要哪些配置，从而帮助你自动实现了这些配置，所以程序员就不需要手动再进行配置了。
这个说起来非常简单的约定，实际上却大大简化了程序员的日常工作，让Spring项目变的非常简单。
@SpringBootApplication
学习SpringBoot，还是要从SpringBoot的入门注解@SpringBootApplication开始：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {可以看到@SpringBootApplication是一个组合注解，由@SpringBootConfiguration+@EnableAutoConfiguration+@ComponentScan组成。
@SpringBootConfiguration的主要作用其实就是实现@Configuration注解的功能，告诉Spring当前类是一个配置类。
然后再加上@ComponentScan注解，告诉Spring容器包扫描路径，由于我们在@SpringBootApplication注解上其实并没有指定包扫描路径，所以，Spring容器会采用默认的包扫描路径：当前配置类所在的路径。因此才有了一个约定：SpringBoot的启动类（其实准确的叫法应该是配置类，配置类不一定必须是启动类，编写一个其他的配置类送给SpringApplication的run方法也是一样可以启动SpringBoot的）要放在项目的主路径下，因为不放在主路径下、而是放在特定包下的话，就可能会导致除这个特定包之外的其他包下的类不能被Spring容器扫描到。
然后最重要的是这个@EnableAutoConfiguration注解，@EnableAutoConfiguration也是一个组合注解：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {主要包含两个注解：@AutoConfigurationPackage和@Import，比较重要的是这个@Import注解。
其实我们可以看到，SpringBoot项目启动时的几个注解实际上都是由Spring注解组合生成的，所以说SpringBoot其实不算是什么新技术，只不过是Spring框架的一个应用，而已。
@EnableAutoConfiguration
接下来我们要重点分析一下@EnableAutoConfiguration注解，因为他是实现“约定大于配置”思想的关键。
前面已经看到了，@EnableAutoConfiguration注解中最重要的其实是@Import注解，所以我们先对@Import注解做一个简单的了解，之后再回来深入学习@EnableAutoConfiguration注解。
@Import注解
@Import注解和@Configuration注解一起作用，放在@Configuration配置类中，作用是通过该配置类引入Bean到Spring IoC容器中。
比如：
@Configuration
@Import(Person.class)
public class MyConfiguration(){
}
public class Person(){
@Bean
public Person createPerson(){
return new Person();
}
}以上配置类通过@Import注解将Person对象注入到SpringIoC容器中。
@Import需要通过参数value指定引入类。
@Import是在Spring Ioc容器刷新的时候、通过BeanFactoryPostProcessors生效的。具体的调用路径：
Spring容器refresh方法 -> AbstractApplicationContext.refresh()->
invokeBeanFactoryPostProcessors()->
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors->
ConfigurationClassPostProcessor.processConfigBeanDefinitions ->
ConfigurationClassParser.parse()->
processConfigurationClass()->
doProcessConfigurationClass()
调用链路特别长，代码也特别多，所以我们今天也就没有办法分析全部代码。但是看到这个doProcessConfigurationClass就感觉快要找到核心代码了，因为Spring源码的特点，doxxxx方法是干实事的。
确实，这个ConfigurationClassParser类是专门用来处理配置类的，也就是加了@Configuration注解的类，@Import注解也是这个类负责解析，这也是@Import注解必须和@Configuration注解绑定才能生效的原因。
doProcessConfigurationClass方法源码也特别长，首先处理@Component、@PropertySource、@ComponentScan注解，之后调用processImports方法处理@Import注解。
processImports方法是正儿八经处理@Import注解的地方。
代码也比较长，我们还是简单一点，只关心比较重要的部分：
for (SourceClass candidate : importCandidates) {
//1.如果@Import的类实现了ImportSelector接口
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports
Class<?> candidateClass = candidate.loadClass();
ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
this.environment, this.resourceLoader, this.registry);
Predicate<String> selectorFilter = selector.getExclusionFilter();
if (selectorFilter != null) {
exclusionFilter = exclusionFilter.or(selectorFilter);
}
if (selector instanceof DeferredImportSelector deferredImportSelector) {
this.deferredImportSelectorHandler.handle(configClass, deferredImportSelector);
}
else {
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
}
}
//2.如果@Import的类实现了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);
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}
//3.@Import引入的是普通类
else {
// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
// process it as an @Configuration class
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
}
}代码中加了注释，其实主要关注的是@Import注解支持引入三种类型的类：
- 第一种是实现了ImportSelector接口的类，这种情况下又判断是否实现了DeferredImportSelector接口，会有不同的处理逻辑，实现了DeferredImportSelector接口的类，最终会调用到其内部接口DeferredImportSelector.Group的process方法，否则，如果没有实现DeferredImportSelector接口，则会调用到ImportSelector的getImports方法。
- 第二种是实现了ImportBeanDefinitionRegistrar接口的类，通过将BeanDefinition注册到Spring容器中从而实现bean加载。
- 第三种是普通类，可以直接加载到SpringIoC容器中。
需要注意的是第一种情况中的DeferredImportSelector接口：
A variation of ImportSelector that runs after all @Configuration beans have been processed. This type of selector can be particularly useful when the selected imports are @Conditional.
Implementations can also extend the org.springframework.core.Ordered interface or use the org.springframework.core.annotation.Order annotation to indicate a precedence against other DeferredImportSelectors.
Implementations may also provide an import group which can provide additional sorting and filtering logic across different selectors.
Since:
4.0
Author:
Phillip Webb, Stephane NicollDeferredImportSelector接口实现类的延迟导入，在所有的@Configuration配置类全部处理之后再运行。这个特性对于@Conditional注解下的条件配置很有用。
实现类也可以扩展Order接口实现对延迟导入配置类的排序，也可以提供一个导入的group实现排序（Group是DeferredImportSelector的子接口）。
以上是DeferredImportSelector类的javaDoc的解释，基本上说清楚了DeferredImportSelector接口的作用，我们今天理解到这个程度就OK了，不影响我们对SpringBoot自动配置原理的理解了。
好了，对于@Import注解的学习就到这里了，有了对@Import注解的基本认识，我们就可以继续深入分析@EnableAutoConfiguration注解了。
@EnableAutoConfiguration
继续研究@EnableAutoConfiguration注解：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {@Import注解引入了AutoConfigurationImportSelector类，这个类是SpringBoot自动配置的关键实现类：
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {发现AutoConfigurationImportSelector类实现了DeferredImportSelector接口，根据上面我们对@Import注解的分析，Spring容器的refresh方法最终会调用到DeferredImportSelector.Group的process方法，我们需要从AutoConfigurationImportSelector源码中找一下process方法的实现。
发现AutoConfigurationImportSelector类实现了一个AutoConfigurationGroup类，该类实现了eferredImportSelector.Group接口，我们找到它的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()));
AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
.getAutoConfigurationEntry(annotationMetadata);
this.autoConfigurationEntries.add(autoConfigurationEntry);
for (String importClassName : autoConfigurationEntry.getConfigurations()) {
this.entries.putIfAbsent(importClassName, annotationMetadata);
}
}process方法强转参数deferredImportSelector为AutoConfigurationImportSelector后，调用getAutoConfigurationEntry方法,拿到需要实例化并放入SpringIoC容器中的类的全限定名之后，返回给Spring容器（我们肯定知道Bean的实例化不会在当前阶段完成、一定是Spring IoC容器统一完成的（还记得吗，入口方法是getBean））。
getAutoConfigurationEntry方法源码会揭露SpringBoot自动装配实现机制的真相：
protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
if (!isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
}
AnnotationAttributes attributes = getAttributes(annotationMetadata);
//找到自动配置，获取需要自动配置的类
List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
//去重
configurations = removeDuplicates(configurations);
//根据排除配置，进行排除
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
//filter方法，实现条件配置，根据条件排除掉不必要的配置
configurations = getConfigurationClassFilter().filter(configurations);
fireAutoConfigurationImportEvents(configurations, exclusions);
return new AutoConfigurationEntry(configurations, exclusions);
}上面加了备注的方法是关键方法，我们一个个看一下。
getCandidateConfigurations
从方法名上可以看出，是要获取到备选的配置项。
代码非常简单：
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
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;
}关键方法loadFactoryNames：
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
ClassLoader classLoaderToUse = classLoader;
if (classLoader == null) {
classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
}
String factoryTypeName = factoryType.getName();
return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}又调用了方法loadSpringFactories：
private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
Map<String, List<String>> result = (Map)cache.get(classLoader);
if (result != null) {
return result;
} else {
HashMap result = new HashMap();
try {
//读取配置文件META-INF/spring.factories
Enumeration urls = classLoader.getResources("META-INF/spring.factories");
while(urls.hasMoreElements()) {
URL url = (URL)urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
Iterator var6 = properties.entrySet().iterator();
while(var6.hasNext()) {
Entry<?, ?> entry = (Entry)var6.next();
String factoryTypeName = ((String)entry.getKey()).trim();
String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
String[] var10 = factoryImplementationNames;
int var11 = factoryImplementationNames.length;
for(int var12 = 0; var12 < var11; ++var12) {
String factoryImplementationName = var10[var12];
((List)result.computeIfAbsent(factoryTypeName, (key) -> {
return new ArrayList();
})).add(factoryImplementationName.trim());
}
}
}
result.replaceAll((factoryType, implementations) -> {
return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
});
cache.put(classLoader, result);
return result;
} catch (IOException var14) {
throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
}
}
}我们先有一个认识：类加载器可以在当前类加载上下文环境下找到指定位置的配置文件。
代码虽然比较长，但是实现的功能比较简单：通过类加载器读取配置文件“META-INF/spring.factories”，加工配置文件内容、放入Map之后返回。
我们简单看一眼META-INF/spring.factories文件的内容：
其中的org.springframework.boot.autoconfigure.AutoConfigurationImportFilter、以及org.springframework.boot.autoconfigure.EnableAutoConfiguration是key，后面的内容是value（是一个list），读取该文件的配置后最终以map的形式返回。
这样的话，getCandidateConfigurations方法就通过类加载器返回配置在META-INF/spring.factories文件中的内容并返回。
这段代码逻辑其实就是SpringBoot自动配置的核心内容，SpringBoot帮助程序员完成配置的机密就在这个META-INF/spring.factories文件中，其实如果没有META-INF/spring.factories文件，SpringBoot也不可能知道他究竟要自动加载哪些Bean！
getExclusions
getExclusions方法完成的功能比较简单，就是检查@Import注解是否有exclude的配置，根据配置对返回的自动配置结合进行排除。
getConfigurationClassFilter().filter
getConfigurationClassFilter().filter方法也非常关键，因为配置文件META-INF/spring.factories中的自动配置类非常多，但是我们的项目中不一定需要，比如RabbitMQ，在META-INF/spring.factories文件中就有关于RabbitMQ的配置，但是如果我们的项目不需要mq的话，SpringBoot就没有必要加载他。
SpringBoot就是通过filter方法来过滤上述不必要加载的组件的。过滤的方法是：
- SpringBoot通过META-INF/spring.factories配置文件指定了AutoConfigurationImportFilter过滤器
- filter方法中通过过滤器，以及各组件的自动配置类完成过滤
比如，RabbitMQ的自动配置类：
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ RabbitTemplate.class, Channel.class })
@EnableConfigurationProperties(RabbitProperties.class)
@Import({ RabbitAnnotationDrivenConfiguration.class, RabbitStreamConfiguration.class })
public class RabbitAutoConfiguration {其中@ConditionalOnClass注解，指定如果当前项目中有RabbitTemplate.class, 以及Channel.class，两个类存在的情况下就执行自动配置，否则，如果不存在的话，RabbitMQ的自动配置类RabbitAutoConfiguration就会被这个filter方法过滤掉，不会被Spring容器加载进来。
而这个“过滤掉”的具体工作，就是由AutoConfigurationImportFilter过滤器完成的。
OK，SpringBoot自动配置的实现原理就搞清楚了！
但是还是有必要提一下SpringBoot3.0，实现自动配置的逻辑和我们上面看到的有变化。
SpringBoot3.0
如果你的项目使用的是SpringBoot3.0，你会发现我上面写的这些内容是在胡说。
因为压根就没有META-INF/spring.factories这个东西！
META-INF/spring.factories其实是在SpringBoot2.7之后就被移除了。
看一下源码，从getCandidateConfigurations开始：
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
List<String> configurations = ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader())
.getCandidates();
Assert.notEmpty(configurations,
"No auto configuration classes found in "
+ "META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you "
+ "are using a custom packaging, make sure that file is correct.");
return configurations;
}关键是这个ImportCandidates.load方法：
public static ImportCandidates load(Class<?> annotation, ClassLoader classLoader) {
Assert.notNull(annotation, "'annotation' must not be null");
//获取类加载器
ClassLoader classLoaderToUse = decideClassloader(classLoader);
String location = String.format(LOCATION, annotation.getName());
//在类加载器的帮助下，获取到指定位置的配置
Enumeration<URL> urls = findUrlsInClasspath(classLoaderToUse, location);
List<String> importCandidates = new ArrayList<>();
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
importCandidates.addAll(readCandidateConfigurations(url));
}
return new ImportCandidates(importCandidates);
}要找到的就是location指定的文件，其中LOCATION定义为：
private static final String LOCATION = "META-INF/spring/%s.imports";
发现配置文件META-INF/spring.factories被META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports取代！
这个变化对既有项目的影响很大！因为虽然SpringBoot自己的自动配置很容易就完成了修改，但是你项目中使用的那些第三方包不一定能够无缝支持！
有关第三方包的自动配置，请关注脚本之家其它相关文章！