Spring boot 自动装配机制
前述
在解析spring boot starter自动装配机制之前，我们先来回顾一下web工程是如何搭建的：
-
gradle/pom文件中引入项目依赖jar包；
-
配置web.xml，Servlet配置，拦截器设置，Listener配置…;
-
数据库连接，配置spring事务；
-
配置视图解析器；
-
开启注解，自动扫描功能
-
配置完成后部署tomcat，调试等…
…
在搭建这些环境的时候是非常耗时间耗精力的，而且有时还会缺斤少两，连蹦bug…
而有了springboot之后，所有的环境配置就会非常便捷。
自动配置原理
我们先来搭建一个最简单的springboot工程，如下：
application.properties文件如下：
server.port=8080
这样，我们就搭好了一个最简单的springboot工程，随后就可以启动了。
我们或许有点好奇，明明自己就只配置了一个端口号，剩下的自己啥也没配，为啥这个web程序就可以启动了？？为什么？？？
接下来，我们来分析以下，以下是我的思路分析过程（为了防止后面看着看着就迷路，我先来个大纲）：
- SpringbootApplication启动类的注解@SpringBootApplication，即程序入口；
- @EnableAutoConfiguration注解（bean的装配与加载）重点；
- @ComponentScan注解（bean的扫描与发现）
程序入口
我们先来看一下主程序入口：
@SpringBootApplication
public class SpringbootStudyApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootStudyApplication.class, args);
}
}
如以上代码，很常见，是一个main方法启动类，与javaEE程序不同的是，它被一个@springbootApplication注解修饰，那么这个注解何德何能，可以让一个web应用跑起来呢？
走进@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 {
@AliasFor(annotation = EnableAutoConfiguration.class)
Class<?>[] exclude() default {};
@AliasFor(annotation = EnableAutoConfiguration.class)
String[] excludeName() default {};
@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
String[] scanBasePackages() default {};
@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
Class<?>[] scanBasePackageClasses() default {};
@AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")
Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
@AliasFor(annotation = Configuration.class)
boolean proxyBeanMethods() default true;
}
我们暂时不要关注这个类的方法，我们先看看这个类上的几个注解：
- @SpringBootConfiguration：在这里可以理解为是一个@Configuration注解；
- @EnableAutoConfiguration：自动装配的核心！！用作bean的装配与加载
- @ComponentScan：扫描包，用作bean的发现（此处扫描当前main下面app的所在包及其下属包）
@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 {};
}
点进去之后可以发现有两个比较重要的注解：
- @AutoConfigurationPackage：其作用是自动配置的包；
- @Import：他的作用是导入需要自动配置的组件；
@AutoConfigurationPackage如下：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
...
}
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
}
@Override
public Set<Object> determineImports(AnnotationMetadata metadata) {
return Collections.singleton(new PackageImports(metadata));
}
}
以上代码的作用就是：
加载启动类所在的包下的主类与子类的所有组件注册到spring容器。
那么问题来了，要搜集并注册到spring容器的那些beans来自哪里？
我们的@import注解就排上用场了，我们也可以细心的发现，@import注解里包括了一个AutoConfigurationImportSelector.class类，那么这个类具体是干嘛的呢？
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
...
//选择导入
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!isEnabled(annotationMetadata)) {
return NO_IMPORTS;
}
AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
}
getAutoConfigurationEntry（）如下：
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);
configurations = getConfigurationClassFilter().filter(configurations);
fireAutoConfigurationImportEvents(configurations, exclusions);
return new AutoConfigurationEntry(configurations, exclusions);
}
//候选者方法如下
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
//扫描所有jar包类路径下 META‐INF/spring.factories 所有EnableAutoConfiguration的值 把扫描到的这些文件的内容包装成properties对象
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;
}
//获取被@EnableAutoConfiguration修饰的类
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
return EnableAutoConfiguration.class;
}
META‐INF/spring.factories 所有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,\
...略
看了以上代码，我们可以发现``AutoConfigurationImportSelector`干了这么几件事：
- 扫描所有jar包类路径下 META‐INF/spring.factories ；
- 把扫描到的这些文件的内容包装成properties对象 ；
- 从properties中获取到EnableAutoConfiguration.class类（类名）对应的值。
来小结一下：
@EnableAutoConfiguration这个注解干了那些事？
- 通过@import注解，引入了
AutoConfigurationImportSelector这个类； AutoConfigurationImportSelector这个类扫描了所有被@EnableAutoConfiguration修饰的类；- 通过上面扫描到的类，通过@AutoConfigurationPackage将其扫描到的类装配到容器中；
接下来我们来看一下被@EnableAutoConfiguration修饰的类长什么样：
以下解析是以
HttpEncodingAutoConfiguration为例解释自动装配的原理的。
@Configuration(proxyBeanMethods = false)//表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
@EnableConfigurationProperties(ServerProperties.class)//启动指定类的 ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；并把 HttpEncodingProperties加入到ioc容器中
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)//Spring底层@Conditional注解（Spring注解版），根据不同的条件，如果 满足指定的条件，整个配置类里面的配置就会生效； 判断当前应用是否是web应用，如果是，当前配置类生效
@ConditionalOnClass(CharacterEncodingFilter.class)//判断当前项目有没有这个类 CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；
@ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true) //判断配置文件中是否存在某个配置 spring.http.encoding.enabled；如果不存在，判断也是成立的 //即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；
public class HttpEncodingAutoConfiguration {
//与SpringBoot的配置文件映射
private final Encoding properties;
//只有一个有参构造器的情况下，参数的值就会从容器中拿，与上述的@EnableConfigurationProperties引进来的文件相呼应。
public HttpEncodingAutoConfiguration(ServerProperties properties) {
this.properties = properties.getServlet().getEncoding();
}
@Bean //给容器中添加一个组件，这个组件的某些值需要从properties中获取
@ConditionalOnMissingBean //判断容器没有这个组件？
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;
}
...略
}
}
ServerProperties文件如下
@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {
/**
* Server HTTP port.
*/
private Integer port;
/**
* Network address to which the server should bind.
*/
private InetAddress address;
@NestedConfigurationProperty
private final ErrorProperties error = new ErrorProperties();
...略
}
首先我们来分析一下：
-
@Configuration与@bean的结合使用相当于是：创建一个基于java代码的配置类，可以用来替代相应的xml配置文件。
-
@EnableConfigurationProperties：引入外部文件，与springboot的配置文件形成映射。
-
其余就是各种@condition条件，达到条件之后，这个类才生效；
下面是一些condition条件的具体应用：
@Conditional扩展注解 作用（判断是否满足当前指定条件） @ConditionalOnJava 系统的java版本是否符合要求 @ConditionalOnBean 容器中存在指定Bean； @ConditionalOnMissingBean 容器中不存在指定Bean； @ConditionalOnExpression 满足SpEL表达式指定 @ConditionalOnClass 系统中有指定的类 @ConditionalOnMissingClass 系统中没有指定的类 @ConditionalOnSingleCandidate 容器中只有一个指定的Bean，或者这个Bean是首选Bean @ConditionalOnProperty 系统中指定的属性是否有指定的值 @ConditionalOnResource 类路径下是否存在指定资源文件 @ConditionalOnWebApplication 当前是web环境 @ConditionalOnNotWebApplication 当前不是web环境 @ConditionalOnJndi JNDI存在指定项
@ComponentScan注解（bean的扫描与发现）
这块就是扫描springboot app程序的所在包，好像也没什么可说的。
总结
springboot的自动状态，我们大致可总结为这么几个步骤：
-
主程序中的@springbootApplication修饰；
-
在@EableAutoConfiguration注解中（实现bean的装配与加载），实现了以下两步：
- @Import引入的AutoCongurationImportSelector负责找到需要导入bean；
- @AutoConfigurationPackage负责将其bean加载到容器中；
被@EableAutoConfiguration修饰的注解：
- 通过@Conguration与@bean使用java的方式配置bean；
- @EnableConfigurationProperties引入配置文件属性，与spring boot的配置文件相映射（这也是为什么你在application.yml里面配置文件的时候可以生效）;
- @Conditionxx条件，满足则存在；
-
@CompomentScan扫描包。（实现bean的扫描与发现）