自动装配是Spring Boot的核心部分，也是Spring Boot功能的基础，正是由于自动装配，才将我们从Bean的繁复配置中解脱出来。那么Spring Boot中的自动装配指的是什么？我们继续以Spring MVC为例，不使用Spring Boot时，我们可能需要配置视图解析器，文件解析器，请求适配器等等各种Bean，如果在使用数据库，redis，还需要配置数据库、redis相关Bean。我们以配置redis为例，如下为Spring中Bean的配置：
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="100"/><!-- 最大闲置 -->
<property name="minIdle" value="10"/><!-- 最小闲置 -->
<property name="testOnBorrow" value="true"/><!-- 可以获取 -->
<!--<property name="testOnReturn" value="true"/>-->
</bean>
<!-- redis 配置,也可以把配置挪到properties配置文件中,再读取 -->
<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
<constructor-arg index="0" ref="jedisPoolConfig" />
<!-- 端口，默认6379 -->
<constructor-arg index="2" value="6379" name="port" type="int"/>
<constructor-arg index="3" value="5000" name="timeout" type="int"/>
<constructor-arg index="1" value="127.0.0.1" name="host" type="java.lang.String"/>
<!-- 如果你需要配置密码，请打开这里。-->
<constructor-arg index="4" value="你的密码" name="password" type="java.lang.String"/>
-->
</bean>而如果使用Spring，我们只需要添加spring-boot-starter-data-redis jar包，然后再application或者application.yml中配置redis所需要的属性如下，Spring Boot会自动装配与Redis有关的Bean，不需要我们在手动配置Bean。
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.pool.max-active=200
spring.redis.pool.max-wait=-1
spring.redis.pool.max-idle=10
spring.redis.pool.min-idle=0
spring.redis.timeout=1000了解Spring Boot的自动装配之后，我们就可以查看Spring Boot的自动装配原理了，这里我们还要从启动类说起，启动类上的注解@SpringBootApplication是一个复合注解，在它上面还有一个@EnableAutoConfiguration注解，代码如下：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
Class<?>[] exclude() default {};
String[] excludeName() default {};
}
这里我们介绍一下@Enable*注解,通过简单的@Enable*来开启一项功能的支持，从而避免自己配置大量的代码，大大降低了使用难度。Spring提供了一系列的@Enable注解，比如@EnableWebMvc，@EnableScheduling，@EnableAsync我们进入拿到这些注解中，毫无意外都是发现注解上都有一个@Import注解。该注解是用来导入配置类的，这也意味着这些开启的实现是导入了一些自动配置的Bean。关于@Import注解的使用可以参考Spring IOC 注解 — @ImportResource，@Import。Spring Boot就是利用该原理进行自动装配的，接下来我们通过源码讲解Spring Boot的自动装配，代码如下所示：
//该方法为ImportSelector的实现，用于返回要注入的Class的名称
public String[] selectImports(AnnotationMetadata annotationMetadata) {
//判断是否开启自动装配功能，
//可以通过spring.boot.enableautoconfiguration配置开启或者关闭
//具体方法在该方法下面
if (!this.isEnabled(annotationMetadata)) {
return NO_IMPORTS;
} else {
//开启自动注解后，通过AutoConfigurationMetadataLoader加载自动配置的元配置数据
AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
//根据加载的元数据配置，将要注入的配置类封装成AutoConfigurationEntry实例。
AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
//返回要注入的配置类的名称。
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
}接下来我们分步解析，上面的代码，首先是自动装配功能的启用，我们通过isEnabled方法判断，取取环境变量spring.boot.enableautoconfiguration的值进行判断，方法如下所示：
protected boolean isEnabled(AnnotationMetadata metadata) {
//该Class实例如果等于AutoConfigurationImportSelector的Class实例
//取环境变量spring.boot.enableautoconfiguration的值，默认为true
//否则取true
return this.getClass() == AutoConfigurationImportSelector.class ?
(Boolean)this.getEnvironment().getProperty("spring.boot.enableautoconfiguration", Boolean.class, true)
:true;
}如果开启了自动装配，然后就是加载配置类，以及Bean的装配,其主要逻辑都在getAutoConfigurationEntry逻辑中，其中loadMetadata方法用于从META-INF/spring-autoconfigure-metadata.properties加载配置元数据，spring-autoconfigure-metadata.properties的内容可以参考spring-boot-autoconfigure-2.1.3.RELEASE.jar中的META-INF目录，里面配置了很多类，这里不再展示。然后封装成Properties属性，代码如下所示：
//从META-INF/spring-autoconfigure-metadata.properties加载配置元数据
public static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
return loadMetadata(classLoader, "META-INF/spring-autoconfigure-metadata.properties");
}
//加载配置元数据
static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
try {
Enumeration<URL> urls = classLoader != null ? classLoader.getResources(path) : ClassLoader.getSystemResources(path);
Properties properties = new Properties();
while(urls.hasMoreElements()) {
properties.putAll(PropertiesLoaderUtils.loadProperties(newUrlResource((URL)urls.nextElement())));
}
return loadMetadata(properties);
} catch (IOException var4) {
throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", var4);
}
}
//最后将配置元数据封装为AutoConfigurationMetadata
static AutoConfigurationMetadata loadMetadata(Properties properties) {
return new AutoConfigurationMetadataLoader.PropertiesAutoConfigurationMetadata(properties);
}接下来我们查看重要的逻辑，getAutoConfigurationEntry方法：
protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
if (!this.isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
} else {
//获取注解的属性
AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
//加载候选配置类，为什么称为候选，因为要加载的配置类，并不一定全部注入到Spring 容器中
//而是根据某种条件帅选出需要的类注入到Spring中。
List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
//删除重复的配置类
configurations = this.removeDuplicates(configurations);
//获取要排除的条件
Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
//检测排除的类是否在配置文件中加载的类中，如果不在会抛出异常
this.checkExcludedClasses(configurations, exclusions);
//配置类排除不需要注入的类
configurations.removeAll(exclusions);
//过滤不需要注入的类
configurations = this.filter(configurations, autoConfigurationMetadata);
//触发自动注入事件
this.fireAutoConfigurationImportEvents(configurations, exclusions);
//返回要注入的配置类
return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
}
}上面的逻辑中，加载配置类，删除重复的逻辑类，检测要排除的类，排除要排除的类这些逻辑都比较简单，其中配置类的加载是从/META-INF/spring.factories中加载的。在上述逻辑之后 this.filter(configurations, autoConfigurationMetadata)方法比较难理解，该方法也是过滤不需要注入的类，该方法使用AutoConfigurationImportFilter接口中的方法进行过滤；AutoConfigurationImportFilter是一个功能型接口，它的实现类是OnClassCondition。OnClassCondition继承FilteringSpringBootCondition，FilteringSpringBootCondition实现。
private List<String> filter(List<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata) {
long startTime = System.nanoTime();
String[] candidates = StringUtils.toStringArray(configurations);
boolean[] skip = new boolean[candidates.length];
boolean skipped = false;
//获取所有的AutoConfigurationImportFilter的实现类
//AutoConfigurationImportFilter是一个功能型接口，它的实现类是OnClassCondition
//OnClassCondition继承FilteringSpringBootCondition，FilteringSpringBootCondition实现AutoConfigurationImportFilter
Iterator var8 = this.getAutoConfigurationImportFilters().iterator();
while(var8.hasNext()) {
AutoConfigurationImportFilter filter = (AutoConfigurationImportFilter)var8.next();
this.invokeAwareMethods(filter);
boolean[] match = filter.match(candidates, autoConfigurationMetadata);
for(int i = 0; i < match.length; ++i) {
if (!match[i]) {
skip[i] = true;
candidates[i] = null;
skipped = true;
}
}
}
.....
}然后我们只需要查看OnClassCondition 类的使用，我们可以任意选一个/META-INF/spring.factories中的配置类，比如DataSourceAutoConfiguration：
@Configuration
@ConditionalOnClass({DataSource.class, EmbeddedDatabaseType.class})
@EnableConfigurationProperties({DataSourceProperties.class})
@Import({DataSourcePoolMetadataProvidersConfiguration.class, DataSourceInitializationConfiguration.class})
public class DataSourceAutoConfiguration {
......
}在DataSourceAutoConfiguration类上我们看到了@ConditionalOnClass注解，继续查看源码：
Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional({OnClassCondition.class})
public @interface ConditionalOnClass {
Class<?>[] value() default {};
String[] name() default {};
}查看上面的源码，我们可以发现@ConditionalOnClass注解上传入了OnClassCondition ，我们可以查看OnClassCondition 类的层次结构图：
从上面的类图中，我们看到OnClassCondition最终实现了Condition接口，该接口可以根据某些条件向Spring容器中注入Bean。我们熟悉的@Profile注解也是由@Conditional注解实现的。OnClassCondition则是如果存在某个类，则向Spring中注入Bean，否则不注入该Bean。除了@ConditionalOnClass注解之外还有一下类似的注解：
@ConditionalOnClass ： classpath中存在该类时起效
@ConditionalOnMissingClass ： classpath中不存在该类时起效
@ConditionalOnBean ： DI容器中存在该类型Bean时起效
@ConditionalOnMissingBean ： DI容器中不存在该类型Bean时起效
@ConditionalOnSingleCandidate ： DI容器中该类型Bean只有一个或@Primary的只有一个时起效
@ConditionalOnExpression ： SpEL表达式结果为true时
@ConditionalOnProperty ： 参数设置或者值一致时起效
@ConditionalOnResource ： 指定的文件存在时起效
@ConditionalOnJndi ： 指定的JNDI存在时起效
@ConditionalOnJava ： 指定的Java版本存在时起效
@ConditionalOnWebApplication ： Web应用环境下起效
@ConditionalOnNotWebApplication ： 非Web应用环境下起效总结：Spring Boot之所以能够自动装配，是从配置文件中加载所有自动装配的类，然后根据规则排除不需要装配的类，最后将需要装配的类名称数组返回，注入到Spring中。看完本篇需要记住以下几点，我们也可以写出自己的starter和自动装配。
1.配置类的加载：/META-INF/spring.factories和META-INF/spring-autoconfigure-metadata.properties
2.@Import注解，可以根据某些规则向Spring 容器中注入一组相关联的类
3.@Conditional 可以根据条件判定该类是否向Spring中注入。
4.@ConditionalOn*注解，是否向Spring 中注入的条件
扫一扫
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
