还记得以前面试的时候,经常被问道,说一下Spring Boot的自动装配原理?
咋一听,原理? 觉得逼格应该挺高, 很高大上的东西, 等自己真正了解之后, 卧槽, 就那么回事。
Spring Boot版本是2.6.13

一. 什么是自动装配?

基于注解的Spring Boot的自动装配是Spring Boot框架中的一种特性，它允许开发者使用注解来简化和自动化应用程序的配置和装配过程。
通过使用@EnableAutoConfiguration特定的注解，Spring Boot可以根据应用程序的依赖关系和配置来自动装配和配置一系列的Bean对象和组件。开发者只需要在相应的类或方法上添加特定的注解，Spring Boot就会根据这些注解的配置信息自动完成相应的初始化和装配工作。
简单来说,就是解放开发者的双手, 一切的脏活累活直接交给Spring Boot来完成。

二. 如何实现自动装配?

在介绍自动装配原理之前, 先举一个生活中的简单例子,某天你发工资了, 要犒劳一下自己, 决定去吃一顿火锅, 来到火锅店扫描点餐, 点了一个鸳鸯锅底,并备注要微辣, 还有一些荤菜和素菜之类的。然后服务端打印了你下单的清单,给到后厨,厨师根据你的清单准备锅底和食材, 一切准备好后,服务员端到你的餐桌上, 直接开吃了。

这个例子重点在于菜单, 需要有人写,还需要有人读,; 例子中大厨就是Spring Boot的角色, 顾客就是写Spring Boot的开发人员, 菜单实际上就是Spring Boot自动装配的配置清单, 所以自动装配实际上就是一个实现这个读的步骤 。
接下来结合源码来具体分析:

1. 配置清单在哪里?

首先pom文件中依赖了spring-boot-starter-web

 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>

其内部实际上又依赖了spring-boot-autoconfigure, 使用mvn dependency:tree -Dverbose生成依赖树, 来验证下

这个配置清单就在spring-boot-autoconfigure的META-INF/spring.factories文件中

在spring.factories文件中, 找到org.springframework.boot.autoconfigure.EnableAutoConfiguration, 下面都是自动装配的配置清单

# Auto Configure  核心配置: 待自动装配的配置清单
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcRepositoriesAutoConfiguration,\
.......省略.......

配置清单已经有了,已经知道在什么位置了, 那么只需要让Spring Boot来读取就行了!

2. 自动装配实现

首先看Spring Boot 项目的启动类

package com.example;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication  
public class SpringBootDemoApplication {public static void main(String[] args) {SpringApplication.run(SpringBootDemoApplication.class, args);}
}

启动类被注解@SpringBootApplication定义,此注解用于标识该类是Spring Boot的配置类。配置类通常用于定义各种Bean（例如数据源、事务管理器等）以及其他配置（例如扫描路径、是否开启自动配置等)

细看注解@SpringBootApplication内部构造

@Target(ElementType.TYPE)   //表明@SpringBootApplication注解只能定义在类上
@Retention(RetentionPolicy.RUNTIME) //表明当注解标注的类编译以被JVM加载方式保留
@Documented   //Java Doc会生成注解信息 
@Inherited  //是否会被继承 
@SpringBootConfiguration //标注在某个类上，表示这是一个Spring Boot的配置类
@EnableAutoConfiguration  //★核心, 开启自动配置功能
//@ComponentScan 扫描包, 相当于在spring.xml 配置中<context:comonent-scan> 
//但是并没有指定basepackage，如果没有指定spring底层会自动扫描当前配置类所有在的包
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {/*** 排除特定的自动配置类，使它们永远不会被应用。返回：要排除的类*/@AliasFor(annotation = EnableAutoConfiguration.class)Class<?>[] exclude() default {};/*** 排除特定的自动配置类名，使它们永远不会被应用。返回：要排除的类名*/@AliasFor(annotation = EnableAutoConfiguration.class)String[] excludeName() default {};/*** 属性可以指定一个或多个包名，用逗号分隔。告诉Spring Boot在启动时需要扫描的包，以查找带有注解的类* @SpringBootApplication(scanBasePackages = {"com.example.package1", "com.example.package2"})*/@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")String[] scanBasePackages() default {};/*** 属性指定一个或多个类，Spring Boot 在启动时会扫描这些类所在的包* @SpringBootApplication(scanBasePackageClasses = {MyClass1.class, MyClass2.class})*/@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")Class<?>[] scanBasePackageClasses() default {};/*** 该属性指定一个自定义的Bean名称生成器。* Spring Boot应用程序中的每个Bean都需要一个唯一的名称来标识它们，通常使用默认的命名策略。* 但是，如果需要对Bean的名称进行自定义，可以通过实现BeanNameGenerator接口并在nameGenerator属性中指定自定义的Bean名称生成器。* 使用自定义的名称生成器可以根据项目需求为Bean生成特定的名称。*/@AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;/*** 该属性指定一个自定义的Bean名称生成器。* 用于控制是否为@Configuration配置类中的@Bean方法生成代理对象* 默认情况下，Spring Boot应用程序会为配置类（也就是带有@Configuration注解的类）中的@Bean方法生成代理对象。* 这样做的目的是为了确保@Bean方法每次调用都返回同一个Bean实例，以充分利用Spring的缓存机制。* 但是，如果希望禁用这种代理行为，可以将proxyBeanMethods属性设置为false。* 禁用代理行为可能会导致@Bean方法每次都创建一个新的Bean实例，可能会降低应用程序的性能。*/@AliasFor(annotation = Configuration.class)boolean proxyBeanMethods() default true;}

可以看到,注解类SpringBootApplication又被@EnableAutoConfiguration注解定义, 这么直白的名字，一看就知道它要开启自动装配，SpringBoot要开始骚了，于是默默进去看源码

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage   //用于指定自动配置类所在的包。它的作用是告诉Spring Boot应该扫描哪个包来寻找自动配置类
@Import(AutoConfigurationImportSelector.class)   //核心
public @interface EnableAutoConfiguration {/*** 一个常量，用于指定一个环境变量或系统属性，用于在启用自动配置时覆盖默认值。* 默认情况下，自动配置是启用的，但可以通过设置这个属性来覆盖默值。如果设置了该属性的值为false，则自动配置将被禁用。*/String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";/*** 用于排除某些自动配置类。可以指定一个或多个类，使其不被自动配置* 例如：@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class})*/Class<?>[] exclude() default {};/*** 与 exclude 属性类似，但是通过指定类的全限定名来排除自动配置类* 例如：@EnableAutoConfiguration(excludeName"org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration")*/String[] excludeName() default {};
}

利用注解@Import导入了AutoConfigurationImportSelector类, 而AutoConfigurationImportSelector类实现了DeferredImportSelector,并重写了getImportGroup()方法

@Override
public Class<? extends Group> getImportGroup() {return AutoConfigurationGroup.class;
}

返回了一个自定义实现DeferredImportSelector.Group类的AutoConfigurationGroup静态内部类, 并重写process()方法

private static class AutoConfigurationGroupimplements DeferredImportSelector.Group, BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {private final Map<String, AnnotationMetadata> entries = new LinkedHashMap<>();private final List<AutoConfigurationEntry> autoConfigurationEntries = new ArrayList<>();private ClassLoader beanClassLoader;private BeanFactory beanFactory;private ResourceLoader resourceLoader;private AutoConfigurationMetadata autoConfigurationMetadata;@Overridepublic void setBeanClassLoader(ClassLoader classLoader) {this.beanClassLoader = classLoader;}@Overridepublic void setBeanFactory(BeanFactory beanFactory) {this.beanFactory = beanFactory;}@Overridepublic void setResourceLoader(ResourceLoader resourceLoader) {this.resourceLoader = resourceLoader;}@Overridepublic 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 = ((AutoConfigurationImportSelector) deferredImportSelector).getAutoConfigurationEntry(annotationMetadata);this.autoConfigurationEntries.add(autoConfigurationEntry);for (String importClassName : autoConfigurationEntry.getConfigurations()) {this.entries.putIfAbsent(importClassName, annotationMetadata);}}........省略......}

Spring Boot内部在解析@Import注解时会调用AutoConfigurationImportSelector.getAutoConfigurationEntry()方法，
下面是Spring Boot 2.6.13版本的源码: 重点关注三个核心点

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {if (!isEnabled(annotationMetadata)) {return EMPTY_ENTRY;}AnnotationAttributes attributes = getAttributes(annotationMetadata);//核心点1: 从META‐INF/spring.factories中获得候选的自动配置类List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);//去重configurations = removeDuplicates(configurations);//核心点2:过滤//第一次过滤:根据EnableAutoConfiguration注解中exclude和excludeName属性，获取不需要自动装配的类名单Set<String> exclusions = getExclusions(annotationMetadata, attributes);//进行排除checkExcludedClasses(configurations, exclusions);//exclusions 也排除configurations.removeAll(exclusions);//第二次过滤: 通过读取spring.factories 中的OnBeanCondition\OnClassCondition\OnWebApplicationCondition进行过滤configurations = getConfigurationClassFilter().filter(configurations);//这个方法是调用实现了AutoConfigurationImportListener的bean..  分别把候选的配置名单，和排除的配置名单传进去做扩展fireAutoConfigurationImportEvents(configurations, exclusions);return new AutoConfigurationEntry(configurations, exclusions);
}

核心点1: 从META‐INF/spring.factories路径读取配置类清单

在SpringFactoriesLoader中的loadSpringFactories()方法中有明确定义

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);if (result != null) {return result;} else {try {//指定了路径Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");MultiValueMap<String, String> result = new LinkedMultiValueMap();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()) {Map.Entry<?, ?> entry = (Map.Entry)var6.next();String factoryTypeName = ((String)entry.getKey()).trim();String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());int var10 = var9.length;for(int var11 = 0; var11 < var10; ++var11) {String factoryImplementationName = var9[var11];result.add(factoryTypeName, factoryImplementationName.trim());}}}cache.put(classLoader, result);return result;} catch (IOException var13) {throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);}}
}

spring.factories配置清单中的内容是不是全部读?
不是的, 根据标识符org.springframework.boot.autoconfigure.EnableAutoConfiguration, 从指定位置读取内容。

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {//从META‐INF/spring.factories中获得候选的自动配置类//读取的配置类有133个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;
}protected Class<?> getSpringFactoriesLoaderFactoryClass() {return EnableAutoConfiguration.class;
}

在源码SpringFactoriesLoader.loadFactoryNames()方法中有定义

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {//从META‐INF/spring.factories中获得候选的自动配置类//读取的配置类有133个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;
}/*** 依据getSpringFactoriesLoaderFactoryClass()可知, 参数factoryType其实就是EnableAutoConfiguration.class*/
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {//factoryTypeName的值就是org.springframework.boot.autoconfigure.EnableAutoConfiguration//刚好对应上spring.factories配置清单上指定位置String factoryTypeName = factoryType.getName(); return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

核心点2: 过滤

为什么需要过滤? 从spring.factories文件中读取到所有配置类,是否都需要进行自动装配,然后让如IOC容器中?
答案是否定的, 并不是都需要进行自动装配, 需要按需装配, 这就需要Spring Boot自己进行选择性的判断。
根据源码AutoConfigurationImportSelector.getAutoConfigurationEntry()方法可知,会进行两次过滤

第一次过滤: 根据EnableAutoConfiguration注解中exclude和excludeName属性

根据EnableAutoConfiguration注解中exclude和excludeName属性，获取不需要自动装配的类名单, 但是从注解SpringBootApplication类中可知, 定义的@EnableAutoConfiguration注解并没有设置exclude和excludeName属性值,所以可忽略

第二次过滤: 通过AutoConfigurationImportFilter过滤器

首先会在spring.factories文件根据org.springframework.boot.autoconfigure.AutoConfigurationImportFilter标识, 在指定位置读取需要进行过滤的内容

# Auto Configuration Import Filters 核心过滤: 根据条件进行许选择性的自动装配
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
org.springframework.boot.autoconfigure.condition.OnClassCondition,\
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition

使用过滤器AutoConfigurationImportFilter, 争对三个spring.factories文件定义的内容分别对注解@OnBeanCondition, @OnClassCondition和@OnWebApplicationCondition进行条件按判断, 不符合条件的不会进行自动装配。
见源码SpringFactoriesLoader中的loadFactories()方法

public static <T> List<T> loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader) {Assert.notNull(factoryType, "'factoryType' must not be null");ClassLoader classLoaderToUse = classLoader;if (classLoader == null) {classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();}//factoryType 是org.springframework.boot.autoconfigure.AutoConfigurationImportFilter//从spring.factories文件的org.springframework.boot.autoconfigure.AutoConfigurationImportFilter指定位置读取内容//集合中有三个//org.springframework.boot.autoconfigure.condition.OnBeanCondition//org.springframework.boot.autoconfigure.condition.OnClassCondition//org.springframework.boot.autoconfigure.condition.OnWebApplicationConditionList<String> factoryImplementationNames = loadFactoryNames(factoryType, classLoaderToUse);if (logger.isTraceEnabled()) {logger.trace("Loaded [" + factoryType.getName() + "] names: " + factoryImplementationNames);}List<T> result = new ArrayList(factoryImplementationNames.size());Iterator var5 = factoryImplementationNames.iterator();while(var5.hasNext()) {String factoryImplementationName = (String)var5.next();result.add(instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse));}AnnotationAwareOrderComparator.sort(result);return result;}

最后过滤完成后, 剩下的就是需要进行自动装配的配置类了

拿HttpEncodingAutoConfiguration配置类,来举例

//标记了@Configuration Spring底层会给配置创建cglib动态代理。 作用：就是防止每次调用本类的Bean方法而重新创建对象，Bean是默认单例的
@Configuration(proxyBeanMethods = false) 
@EnableConfigurationProperties(ServerProperties.class)  //启用可以在配置类设置的属性 对应的类
//条件注解, 当前是web环境,条件成立,才进行自动装配
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET) 
//条件注解,容器中必须有CharacterEncodingFilter类,条件成立,才进行自动装配
@ConditionalOnClass(CharacterEncodingFilter.class) 
//条件注解, 表示配置文件application.properties有server.servlet.encoding配置,且定义的值是enabled时,条件成立,允许进行自动装配
@ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true) 
public class HttpEncodingAutoConfiguration {private final Encoding properties;public HttpEncodingAutoConfiguration(ServerProperties properties) {this.properties = properties.getServlet().getEncoding();}@Bean@ConditionalOnMissingBean  // 当IOC容器中没有CharacterEncodingFilter时,才会创建public CharacterEncodingFilter characterEncodingFilter() {CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();filter.setEncoding(this.properties.getCharset().name());filter.setForceRequestEncoding(this.properties.shouldForce(Encoding.Type.REQUEST));filter.setForceResponseEncoding(this.properties.shouldForce(Encoding.Type.RESPONSE));return filter;}@Beanpublic LocaleCharsetMappingsCustomizer localeCharsetMappingsCustomizer() {return new LocaleCharsetMappingsCustomizer(this.properties);}......省略......
}

当注解@ConditionalOnWebApplication, @ConditionalOnClass和@ConditionalOnProperty定义的条件都成立时, 那么Spring Boot就会对该配置类里被注解@Bean定义的方法,进行自动装配, 创建对应的Bean对象,然后放入IOC容器中。这样当Spring Boot正常运行后,就可以直接从IOC容器中拿Bean对象直接使用了。

3. 总结自动装配的实现原理

从从spring-boot-autoconfigure JAR包的META-INF/spring.factories文件中获取的配置列表起初有133个

经过层层过滤之后, 最后还剩下24个

最后结合例子和源码详解,Spring Boot基于注解的自动装配的原理,是不是很简单。