5.Spring Boot自动配置

目录

---

Spring Boot专栏目录（点击进入…）

---

---

Spring Boot自动配置

Spring Boot提供了对应用进行自动化配置。相比以前 XML 配置方式，很多显式方式申明是不需要的。二者，大多数默认的配置足够实现开发功能，从而更快速开发

什么是自动配置？

Spring Boot提供了默认的配置，如默认的Bean。去运行Spring应用。它是非侵入式的，只提供一个默认实现
大多数情况下，自动配置的Bean满足了现有的业务场景，不需要去覆盖。但如果自动配置做的不够好，需要覆盖配置。比如通过命令行动态指定某个jar，按不同环境启动。那怎么办？这里先要考虑到配置的优先级
Spring Boot不单单从application.properties获取配置，可以在程序中多种设置配置属性

自动装配是Spring Boot中一大特性，即Spring Boot在程序初始化时可以根据classpath类、property属性、context中实例、以及运行容器特征等各种动态条件，来按需初始化相应的bean并交付给终端使用

自动装配原理

（1）Spring Boot启动的时候加载主配置类，开启了自动配置功能@EnableAutoConfiguration
（2）@EnableAutoConfiguration作用
（3）从所有jar包的classpath中搜寻所有的META-INF/spring.factories配置文件，并将其中org.springframework.boot.autoconfigure.EnableutoConfiguration对应的配置项通过反射（Java Refletion）实例化为对应的标注了@Configuration的JavaConfig形式的IoC容器配置类，然后汇总为一个并加载到IoC容器。这些功能配置类要生效的话，会去classpath中找是否有该类的依赖类（也就是pom.xml必须有对应功能的jar包才行）并且配置类里面注入了默认属性值类，功能类可以引用并赋默认值。生成功能类的原则是自定义优先，没有自定义时才会使用自动装配类。即将类路径下META-INF/spring.factories里面配置的所有EnableAutoConfiguration的值加入到了容器中

核心注解（@SpringBootApplication）

官方推荐在程序的main class（主方法）上使用注解@SpringBootApplication，对Spring应用进行自动配置，从分析这个注解开始

@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：表明被标注的类提供了Spring Boot应用的配置，其实这个注解与@Configuration注解的功能类似；实际上就是@Configuration，表明这是一个IOC容器的配置类，相当于说明该bean是一个spring中的xml文件

@Configuration
public class ShiroConfig {
	@Bean
	public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
	}
}

@ComponentScan

指定需要扫描包的路径。@SpringBootApplication也提供了相应属性，指定需要扫描哪些package或不扫描哪些package。官方建议将应用的main class放置于整个工程的根路径，并用@SpringBootApplication注解修饰main class，这样整个项目的子package就都会被自动扫描包含
指定了Spring中的指定MVC环境扫描包和Spring IOC的扫描包，扫描路径就是该类所在的所有包。SpringBoot的注解扫描所有的同路径下的类，@Controller类归位MVC类，其它类为Spring的类

// 常规mvc配置指定包
<context:component-scan base-package="com.test.Action" />
// Spring也要指定Spring的注解类的扫描路径
<context:component-scan base-package="com.test" />

建议的工程结构如下所示，其中Application就是应用的main class

com
     +- my（文件夹）
         +- Application.java
         +- beans
         |   +- Customer.java
         |   +- CustomerController.java
         +- controller
             +- Order.java
             +- OrderController.java

@EnableAutoConfiguration：

最重要的注解。实现了对Spring Boot应用自动装配的功能。

@EnableAutoConfiguration利用SpringFactoriesLoader机制加载自动装配配置的，它的配置数据在META-INF/spring.factories中。表示开启Spring Boot自动配置功能，Spring Boot会根据应用的依赖、自定义的bean、classpath下有没有某个类等等因素来猜测你需要的bean，然后注册到IOC容器中

@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}

打开spring-boot-autoconfigure jar下WEB-INF/spring.factories文件，发现EnableAutoConfiguration对应着N多XXXAutoConfiguration配置类；可以看到Spring Boot提供了N多XXXAutoConfiguration类，有Spring Framework的、Web的、redis的、JDBC的等等。

从其中选择HttpEncodingAutoConfiguration这个类来看下它是如何实现自动配置的：

@Configuration
@EnableConfigurationProperties(HttpProperties.class)
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
@ConditionalOnClass(CharacterEncodingFilter.class)
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled",
            matchIfMissing = true)
public class HttpEncodingAutoConfiguration {
	private final HttpProperties.Encoding properties;
	
	public HttpEncodingAutoConfiguration(HttpProperties properties) {
		this.properties = properties.getEncoding();
	}
	
	@Bean
	@ConditionalOnMissingBean
	public CharacterEncodingFilter characterEncodingFilter() {
		CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
		filter.setEncoding(this.properties.getCharset().name());
		filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
		filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
		return filter;
	}
	
}

上面代码表示，只有在满足如下条件时，才会注入characterEncodingFilter这个bean：
1.只有在WebApplication的情况
2.classpath上必须存在CharacterEncodingFilter类
3.配置文件中配置了spring.http.encoding.enabled为true或者没有配置
4.Spring容器中不存在类型为CharacterEncodingFilter的bean

功能分析

传统的Spring项目会有很多的配置文件，比如使用Redis，一般除了对应的依赖的jar包还需要在application.xml里面配置JedisConnectionFactory、JedisPoolConfig、RedisTemplate。但是如果使用Spring Boot的话，系统会根据pom.xml里面的jar包，自动生成这些类并且注入到IOC容器当中

1.传统Spring项目中需要配置

<bean id="jedisConnectionFactory" class="JedisConnectionFactory"/>
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig"/>
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"/>

2.而使用Spring Boot的话，除了pom.xml引入相应的jar包外，只需要在application.properties配置对应的属性值即可

自动装配的过程

1.通过各种注解 + 继承，引入包含自动装配核心方法的类
2.SpringApplication.run(Application.class, args)在运行时，调用自动装配方法
自动装配方法会读取spring-boot-autoconfigure.jar里面的spring.factories配置文件，配置文件中有所有自动装配类的配置类的类名

3.生成对应功能的Configuration类，这些功能配置类要生效的话，会去classpath中找是否有该类的依赖类（也就是pom.xml必须有对应功能的jar包才行）

4.配置类里再通过判断生成最后的功能类，并且配置类里面注入了默认属性值类，功能类可以引用并赋默认值。生成功能类的原则是自定义优先，没有自定义时才会使用自动装配类

综上所述，要想自动装配一个类需要满足2个条件：
1.spring.factories里面有这个类的配置类（一个配置类可以创建多个围绕该功能的依赖类）
2.pom.xml里面需要有对应的jar包

自动装配的结果：
1.根据各种判断和依赖，最终生成了业务需要的类并且注入到IOC容器当中了
2.自动装配生成的类赋予了一些默认的属性值

注解引用线路图
复合注解 + @import加载了对应的类进来，然后在程序启动方法里面，间接调用自动加载类的方法
–>@SpringBootApplication
–>@EnableAutoConfiguration
–>@Import(EnableAutoConfigurationImportSelector.class)
–>extends AutoConfigurationImportSelector
–>selectImports()
–>getExcludeAutoConfigurationsProperty()

通过注解引用，最终在SpringApplication.run()方法的时候，会调用selectImports()，最终加载自动装配

private List<String> getExcludeAutoConfigurationsProperty() {
	RelaxedPropertyResolver resolver = 
	          new RelaxedPropertyResolver(this.environment, "spring.autoconfigure.");
}

派生注解

@Conditional派生注解（Spring注解版原生的@Conditional作用）
作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配里面的所有内容才生效

@Conditional扩展注解	作用（判断是否满足当前指定条件）
@ConditionalOnJava	系统的java版本是否符合要求
@ConditionalOnBean	如果此Bean实例已存在，则执行（如果修饰在class上，则此类加载；如果修饰在方法上 ，则此方法执行）。通常用于限定“如果必备的bean已经被初始化时，才会自动装备当前实例”
@ConditionalOnMissingBean	如果此Bean实例尚未被初始时，则执行
@ConditionalOnExpression	满足SpEL表达式指定
@ConditionalOnClass	如果classpath中存在此类（且可被加载）时，则执行
@ConditionalOnMissingClass	如果class中不存在此类时，则执行
@ConditionalOnSingleCandidate	容器中只有一个指定的Bean，或者这个Bean是首选Bean
@ConditionalOnProperty	如果Envrionment中存在此property、或者相应的property参数值匹配时，则执行。比如springboot中，各种内置的组件是否enabled，就是根据此条件判断
@ConditionalOnWebApplication	如果当前容器为WEB时，则执行。比如初始化springMVC、restTemplate、各种endpoint初始化等
@ConditionalOnNotWebApplication	当前不是web环境
@ConditionalOnJndi	JNDI存在指定项

此外Spring Boot还提供了其他更多的Condition判断，按需使用即可。在Spring Bean容器初始化之前、Envrionment准备就绪之后，将根据spring.factories文件中指定的AutoConfiguration类列表逐个解析上述Condition，并在稍后有序加载、初始化相关Bean

条件注解
在Spring Boot中，提供了很多@ConditionOnXXX的注解，这些注解都在包
org.springframework.boot.autoconfigure.condition下面。

（1）@Conditional

根据某一个条件是否成立来判断是否构建Bean。借助Condition接口可以表示一个特定条件（表示在满足某种条件后才初始化一个bean或者启用某些配置）
自定义编写条件类，实现Condition接口，并覆盖它的matches()方法；返回的boolean值也就是条件是否成立

例如下面代码实现了一个条件，当然这个条件始终成立：

public class SampleCondition implements Condition {
	@Override
	public boolean matches(ConditionContext conditionContext,AnnotatedTypeMetadata annotatedTypeMetadata){
		// 条件成立返回true， 反之返回false
		return true;
	}
}

有了表达条件的类SampleCondition，接下来就可以通过@Conditional注解对创建bean的函数进行配置：

@Configuration
public class ConditionConfig {
	//只有当满足SampleCondition指定的条件时，参会构造id时sampleBean这个bean
	//当然这里的条件始终成立
	@Conditional(SampleCondition.class)
	@Bean
	public SampleBean sampleBean() {
		return new SampleBean();
	}
}

由于SampleCondition的matches方法返回true，表示创建bean的条件成立，所以sampleBean会被创建。如果matches返回false，sampleBean就不会被构建

（2）@ConditionalOnClass

表示只要在classpath下找得到对应的class文件（类），该配置类、或者方法才会生效

@ConditionalOnClass的具体代码如下：

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {
	Class<?>[] value() default {};
	String[] name() default {};
}

@ConditionalOnClass具体的判断逻辑可参看OnClassCondition类

比如：classpath中有Billy.class，这个配置类才生效，也就是Fighter这个Bean才会注入到IOC容器中

@Configuration
@ConditionalOnClass({Billy.class})
public class VanConfig {
	@Bean
	public Fighter billy(){
		return new Billy();
	}
}

（3）@ConditionalOnBean

表示在IOC环境下，contains Bean为true的时候，才通过

例如下面，即使classpath下存在Test.class，但是Test.class没有注入到IOC中，也会报错。HelloService注入失败

@Bean
@ConditionalOnBean(Test.class)
public HelloService test(){
	return new HelloService();
}

（4）@ConditionalOnMissingBean

很厉害的注解，实现默认配置时自定义优先。如果上下文（IOC环境）中已经有这个Bean了就忽略，没有这个Bean的话，才执行返回默认自动装配Bean

比如应用要依赖Animal接口，如果手动注入一个animal，那么就以注入的bean为准，如果未注入，则会被@ConditionalOnMissingBean检测到，就使用默认的AutoConfigAnimal作为bean

@RestController
public class MyRun {
	@Autowired
	private Animal animal;
	
	@RequestMapping("/auto/home")
	public String home(){
		return animal.eat();
	}
}

@Component("animal")
public class Human implements Animal{
	public String eat() {
		return "eat rice";
	}
}

@Configuration
public class TestConfig {
	@Bean
	@ConditionalOnMissingBean(Animal.class)
	public Animal test(){
		return new AutoConfigAnimal();
	}
}

public class AutoConfigAnimal implements Animal{
	public String eat() {
		return "eat anything";
	}
}

装配时机

装配时机	描述
@AutoConfigureAfter	在指定的其他自动装配类初始化之后，才装配当前类
@AutoConfigureBefore	在指定的其他装配类初始化之后，才装配当前类
@AutoConfigureOrder	指定当前类装配的优先级，类似于Ordered接口

自动装配需要的条件：
每个可以自动装配的Spring Boot类，通常具备如下几个特征：
（1）使用@Configuration修饰，且此类不应该被@ComponentScan包含
（2）类上可以被@Conditional*修饰
（3）构造函数不应该为private；构造函数中的参数类，可以被spring容器注入
（4）此类必须在META-INF/spring.factories中声明（注册），才能被Spring Boot感知
（5）Spring Boot中自动装配的类，需要设计好加载或者引用其他bean的顺序，否则可以引入“循环依赖”问题，导致容器初始化失败
（6）自动装配类，通常配合@ConfigurationProperties完成一些属性的配置和bean加载，当然@ConfigurationProperties并不是必须的

Spring Boot自动装配总结

Spring Boot自动装配的原理并不是非常复杂，其实背后的主要原理就是条件注解。

当使用@EnableAutoConfiguration注解激活自动装配时，实质对应着很多XXXAutoConfiguration类在执行装配工作，这些XXXAutoConfiguration类是在spring-boot-autoconfigure jar中的META-INF/spring.factories文件中配置好的，@EnableAutoConfiguration通过SpringFactoriesLoader机制创建XXXAutoConfiguration这些bean。XXXAutoConfiguration的bean会依次执行并判断是否需要创建对应的bean注入到Spring容器中

在每个XXXAutoConfiguration类中，都会利用多种类型的条件注解@ConditionOnXXX对当前的应用环境做判断

如应用程序是否为Web应用、classpath路径上是否包含对应的类、Spring容器中是否已经包含了对应类型的bean。如果判断条件都成立，XXXAutoConfiguration就会认为需要向Spring容器中注入这个bean，否则就忽略

Spring Boot自动配置示例

（1）基于XML对Spring进行配置

spring boot的自动配置是基于spring framework提供的特性实现的

在以往使用spring framework进行程序开发时，相信大家也只是使用XML搭配注解的方式对spring容器进行配置

例如：在XML文件中使用<context:component-scan base-package=“*”/>指定spring需要扫描package的根路径。

（2）Java代码进行Spring配置

两个核心注解@Configuration和@Bean

@Configuration
public class AppConfig {
    @Bean
    public SampleService sampleService() {
        return new SampleServiceImpl();
    }
}

@Bean：用于修饰方法，方法的返回值会作为一个bean装载到spring容器中。bean的id就是方法的名字
@Configuration：用于修饰一个类，它表明这个类的作用是用来对spring容器进行配置的

相当于下面的XML配置：

<bean id="sampleService" class="com.*.SampleServiceImpl"/>

使用AnnotationConfigApplicationContext类构建一个spring容器，从容器中取出对应的bean的测试代码如下：

public static void main(String[] args) {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
    SampleService myService = ctx.getBean("sampleService",SampleService.class);
	myService.doService();
}

配置ComponentScan（扫描包路径）
@ComponentScan注解：指定需要扫描package的根路径

@Configuration
@ComponentScan(basePackages = "com.*.service.impl")
public class AppConfig {}

相当于下面的XML配置：

<context:component-scan base-package="com.*.service.impl"/>

此外，AnnotationConfigApplicationContext类还提供了scan方法用于指定要扫描的包路径。
也就是可以代替@ComponentScan(basePackages = “com..”)
可以删除AppConfig类上的@ComponentScan注解，在构造spring容器时使用下面代码

public static void main(String[] args) {
	AnnotationConfigApplicationContext ctx =  new AnnotationConfigApplicationContext();
	ctx.scan("com.*.service.impl");
	ctx.refresh();
	SampleService myService = ctx.getBean("sampleService",SampleService.class);
	myService.doService();
}

（3）使用@Import组合多个XML配置

将所有的spring配置全部放在同一个类中肯定是不合适的，这会导致那个配置类非常复杂。通常会创建多个配置类，再借助@Import将多个配置类组合成一个

@Import的功能类似于XML中的<import/>

@Configuration
public class ConfigA {
    @Bean
    public A a() {
        return new A();
    }
}

@Configuration
@Import(ConfigA.class)
public class ConfigB {
    @Bean
    public B b() {
        return new B();
    }
}

上面的代码分别创建了两个配置类ConfigA和ConfigB，它们分别定义了a和b两个Bean。在ConfigB上使用@Import注解导入ConfigA的配置，此时应用代码如果加载ConfigB的配置，就自动也加载了ConfigA的配置（使用了@Import之后，加载这个配置也会加载@Import导入的配置）

public static void main(String[] args) {
    // 只加载ConfigB一个配置类，但同时也包含了ConfigA的配置
    ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);
    A a = ctx.getBean(A.class);
    B b = ctx.getBean(B.class);
    System.out.println(a);
	System.out.println(b);
}

@Import还可以同时导入多个配置类；当有多个配置类需要同时导入

@Configuration
@Import({ServiceConfig.class, RepositoryConfig.class})
public class SystemTestConfig {
    @Bean
    public DataSource dataSource() {
        // return new DataSource
    }
}

Redis自动装配示例

1.从spring-boot-autoconfigure.jar/META-INF/spring.factories中获取120多个默认功能配置类，其中包括redis的功能配置类RedisAutoConfiguration的全限定名

org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\

2.RedisAutoConfiguration配置类生效的一个条件是@ConditionalOnClass

（JedisConnection.class, RedisOperations.class, Jedis.class）,所以会去classpath下去查找对应的class文件

@Configuration
@ConditionalOnClass({  JedisConnection.class, 
										RedisOperations.class, 
										Jedis.class })
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
	@Bean	        
	@ConditionalOnMissingBean(RedisConnectionFactory.class)
	public JedisConnectionFactory redisConnectionFactory() throws UnknownHostException {
		return applyProperties(createJedisConnectionFactory());
	}
}

3.如果pom.xml有对应的jar包,就能匹配到对应依赖class（JedisConnection.class, RedisOperations.class, Jedis.class）

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

4.匹配成功，这个功能配置类才会生效，同时会注入默认的属性配置类@EnableConfigurationProperties(RedisProperties.class)

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
	private int database = 0;
	private String url;
	private String host = "localhost";
	private String password;
	private int port = 6379;
}

5.Redis功能配置里面会根据条件生成最终的JedisConnectionFactory、RedisTemplate,条件就是IOC环境里面，没有用户自定义的

@ConditionalOnMissingBean(RedisConnectionFactory.class)、RedisTemplate

@Configuration
@ConditionalOnClass({ JedisConnection.class, RedisOperations.class, Jedis.class })
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(RedisConnectionFactory.class)
	public JedisConnectionFactory redisConnectionFactory()
		                throws UnknownHostException {
		return applyProperties(createJedisConnectionFactory());
	}
	
	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	public RedisTemplate<Object, Object> redisTemplate(
	RedisConnectionFactory redisConnectionFactory)
		                        throws UnknownHostException {
		RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}
	
}

最终创建好的默认装配类，会通过功能配置类里面的 @Bean注解，注入到IOC当中

依赖的注解（Redis示例）

1.@SpringBootApplication：项目应用启动类的注解，其实是3个注解的组合：
@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan，其中在自动装配中起作用的是第二个

2.@EnableAutoConfiguration：表示应用启动自动装配的功能（包括加载对应的Bean到IOC容器中，且根据默认配置对属性赋值）

3.@Import(EnableAutoConfigurationImportSelector.class)：这个注解比较厉害，可以把没有注册到IOC中的Bean强行注册到IOC中,表示启动自动配置功能需要引入EnableAutoConfigurationImportSelector.class才行

4.@Configuration

5.@ConditionalOnClass({ JedisConnection.class, RedisOperations.class, Jedis.class })
表示让RedisAutoConfiguration配置类起作用的话，必须有包含这些类的jar包才行

6.@EnableConfigurationProperties(RedisProperties.class)：表示默认引用RedisProperties.class里面的配置

7.@ConditionalOnMissingBean(RedisConnectionFactory.class)：表示如果用户没有自定义注入RedisConnectionFactory.class类，才会使用默认的JedisConnectionFactory

Spring Boot自动装配的过程

1.通过各种注解实现了类与类之间的依赖关系，容器在启动的时候Application.run，会调用EnableAutoConfigurationImportSelector.class的selectImports()方法（其实是其父类的方法）

2.selectImports方法最终会调用SpringFactoriesLoader.loadFactoryNames方法来获取一个全面的常用BeanConfiguration列表

3.loadFactoryNames方法会读取FACTORIES_RESOURCE_LOCATION（也就是spring-boot-autoconfigure.jar 下面的spring.factories），获取到所有的Spring相关的Bean的全限定名ClassName，大概120多个

4.selectImports()方法继续调用filter(configurations, autoConfigurationMetadata);这个时候会根据这些BeanConfiguration里面的条件，来一一筛选，最关键的是@ConditionalOnClass，这个条件注解会去classpath下查找，jar包里面是否有这个条件依赖类，所以必须有了相应的jar包，才有这些依赖类，这个时候这些功能配置类才会生效

5.功能配置类生效后，会获取到依赖的默认属性值类，里面有一些该功能的默认属性值

6.功能配置类里面配置了最终的功能Bean，这个时候会通过@ConditionalOnMissingBean先判断用户是否自定义了，如果用户没有自定义，就创建一个默认的功能类，并且注入到IOC中

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
	Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
	List<String> result = new ArrayList<String>();
	while (urls.hasMoreElements()) {
		URL url = urls.nextElement();
		Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
		String factoryClassNames = properties.getProperty(factoryClassName);
		result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
	}
	return result;
}