spring boot 四大组件之Auto Configuration

SpringBoot 自动配置主要通过 @EnableAutoConfiguration, @Conditional, @EnableConfigurationProperties 或者 @ConfigurationProperties 等几个注解来进行自动配置完成的。

@EnableAutoConfiguration 开启自动配置，主要作用就是调用 Spring-Core 包里的 loadFactoryNames()，将 autoconfig 包里的已经写好的自动配置加载进来。

@Conditional 条件注解，通过判断类路径下有没有相应配置的 jar 包来确定是否加载和自动配置这个类。

@EnableConfigurationProperties 的作用就是，给自动配置提供具体的配置参数，只需要写在 application.properties 中，就可以通过映射写入配置类的 POJO 属性中。

@SpringBootApplication = @EnableAutoConfiguration + @ComponentScan + @Configuration

@EnableAutoConfiguration

@Enable*注释并不是SpringBoot新发明的注释，Spring 3框架就引入了这些注释，用这些注释替代XML配置文件。比如：
@EnableTransactionManagement注释，它能够声明事务管理
@EnableWebMvc注释，它能启用Spring MVC
@EnableScheduling注释，它可以初始化一个调度器。

这些注释事实上都是简单的配置，通过@Import注释导入。

从启动类的@SpringBootApplication进入，在里面找到了@EnableAutoConfiguration,

@EnableAutoConfiguration里通过@Import导入了EnableAutoConfigurationImportSelector,

进入他的父类AutoConfigurationImportSelector

找到selectImports()方法，他调用了getCandidateConfigurations()方法，在这里，这个方法又调用了Spring Core包中的loadFactoryNames()方法。这个方法的作用是，会查询META-INF/spring.factories文件中包含的JAR文件。

当找到spring.factories文件后，SpringFactoriesLoader将查询配置文件命名的属性。

Jar文件在org.springframework.boot.autoconfigure的spring.factories

spring.factories内容如下(截取部分),在这个文件中，可以看到一系列Spring Boot自动配置的列表

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.cloud.CloudAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
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.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\

下面我们来看自动配置redis的细节，RedisAutoConfiguration：

RedisAutoConfiguration

这个类进行了简单的Spring配置，声明了Redis所需典型Bean，和其它很多类一样，重度依赖于Spring Boot注释：
1）@ConditionOnClass激活一个配置，当类路径中存在这个类时才会配置该类
2）@EnableConfigurationProperties自动映射一个POJO到Spring Boot配置文件（默认是application.properties文件）的属性集。
3）@ConditionalOnMissingBean启用一个Bean定义，但必须是这个Bean之前未定义过才有效。
还可以使用@ AutoConfigureBefore注释、@AutoConfigureAfter注释来定义这些配置类的载入顺序。

着重了解@Conditional注释，Spring 4框架的新特性

此注释使得只有在特定条件满足时才启用一些配置。SrpingBoot的AutoConfig大量使用了@Conditional，它会根据运行环境来动态注入Bean。这里介绍一些@Conditional的使用和原理，并自定义@Conditional来自定义功能。

• @Conditional是SpringFramework的功能，SpringBoot在它的基础上定义了
• @ConditionalOnClass，@ConditionalOnProperty等一系列的注解来实现更丰富的内容。

具体几个@Conditon*注解的含义

@ConditionalOnBean

仅仅在当前上下文中存在某个对象时，才会实例化一个Bean

@ConditionalOnClass

某个class位于类路径上，才会实例化一个Bean)，该注解的参数对应的类必须存在，否则不解析该注解修饰的配置类

@ConditionalOnExpression

当表达式为true的时候，才会实例化一个Bean

@ConditionalOnMissingBean

仅仅在当前上下文中不存在某个对象时，才会实例化一个Bean，该注解表示，如果存在它修饰的类的bean，则不需要再创建这个bean，可以给该注解传入参数例如@ConditionOnMissingBean(name = "example")，这个表示如果name为“example”的bean存在，这该注解修饰的代码块不执行

@ConditionalOnMissingClass

某个class类路径上不存在的时候，才会实例化一个Bean

@ConditionalOnNotWebApplication

不是web应用时，才会执行

---

2.Properties系列注释

@EnableConfigurationProperties
@ConfigurationProperties(prefix = "may")

在需要注入配置的类上加上这个注解，prefix的意思是，以该前缀打头的配置，以下是例子

    @ConfigurationProperties(prefix = "may")
    public class User {
        private String name;
        private String gender;  
       //省略setter,getter方法
    }  

application.yml中的配置

   may
      name: youjie
      gender: man

如果不用系统初始的application.yml配置类，而是使用自己的如youjie.yml，可以如下配置

    @ConfigurationProperties(prefix = "may",locations = "classpath:youjie.yml")
    public class User2 {
        private String name;
        private String gender;  
       //省略setter,getter方法
    }
  

过时：由于Spring-boot 1.5.2版本移除了，locations这个属性,因此上述这种方式在最新的版本中过时。
@PropertySource

Spring-boot 1.5.2版本之后，采用下面这种方式

@Component
//@PropertySource只能加载.properties文件，需要将上面的yml文件，改为.properties文件
@PropertySource("classpath:may.properties")
@ConfigurationProperties(prefix="may")
public class User2 {
        private String name;
        private String gender;  
       //省略setter,getter方法
    }  

@EnableConfigurationProperties

最后注意在spring Boot入口类加上@EnableConfigurationProperties

    @SpringBootApplication
    @EnableConfigurationProperties({User.class,User2.class})
    public class DemoApplication {  
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }
    }  

其实这里@EnableConfigurationProperties({User.class,User2.class}) 可以省略

1. 通过启动类创建Spring Boot应用
创建Spring Boot应用非常简单，只要创建一个包含main的启动类即可。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class App
{
public static void main(String[] args)
{
ApplicationContext ctx = SpringApplication.run(App.class, args);
}
}
上面这个类被称为Spring Boot应用的启动类，它通过一个java的main（）方法来引导和启动一个Spring应用。它通常包含了以下内容：

创建一个Spring ApplicationContext实例。
接收命令行参数并将其转为Spring属性。
按照配置加载所有Spring Bean。可以根据项目需求进行其他操作。
2. @SpringBootApplication注解
这个注解其实是一个应用了3个注解的快捷方式。

2.1 @SpringBootConfiguration
@SpringBootConfiguration是在Spring Boot2中出现的一个新的注解。之前我们都是使用的 @Configuration注解，可以用 @Configuration来替换它，2个都是实现同样的功能。

它表示该类是一个配置类，应该对其进行扫描，以获得进一步的配置和bean定义。

2.2 @EnableAutoConfiguration
此注解用于启用Spring Application Context的自动配置，尝试猜测和配置您可能需要的bean。自动配置类通常基于您的类路径以及您定义的bean来应用。

自动配置尝试尽可能智能，并在您定义更多自己的配置时进行后退。您始终可以使用两种方法来手动排除任何您不想应用的配置：

使用excludeName（）
使用spring.autoconfigure.exclude属性文件中的属性。
2.3 @ComponentScan
此注解提供了与Spring XML context:component-scan元素并行的支持。

无论是basePackageClasses()或basePackages()可以定义特定的软件包进行扫描。如果未定义特定包，则将从声明此注解的类的包进行扫描。

3.自定义自动配置
要创建自定义自动配置，我们需要创建一个注释为@Configuration的类并注册它。

让我们为MySQL数据源创建自定义配置：

@Configuration
public class MySQLAutoconfiguration {
//...
}

下一个必须的步骤是通过在标准文件资源/ META-INF / spring.factories中的属性org.springframework.boot.autoconfigure.EnableAutoConfiguration下添加类的名称，将类注册为自动配置候选者：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.peterwanghao.samples.springboot.autoconfiguration.MySQLAutoconfiguration

如果我们希望我们的自动配置类优先于其他自动配置候选者，我们可以添加@AutoConfigureOrder（Ordered.HIGHEST_PRECEDENCE）注解。

自动配置是使用标有@Conditional注解的类和bean设计的，以便可以替换自动配置或其特定部分。

请注意，只有当应用程序中未定义自动配置的bean时，自动配置才有效。如果您定义了bean，那么将覆盖默认值。

3.1 基于类的条件注解
Class conditions允许我们指定使用@ConditionalOnClass注解指定的类，或者使用@ConditionalOnMissingClass注解来指定不存在于 classpath 上的类。

让我们指定只有存在类DataSource的情况下才会加载MySQLConfiguration，在这种情况下我们可以假设应用程序将使用数据库：

@Configuration
@ConditionalOnClass(DataSource.class)
public class MySQLAutoconfiguration {
//...
}
3.2 基于Bean的条件注解
如果我们只想在指定的bean存在的情况下包含bean，我们可以使用@ConditionalOnBean和@ConditionalOnMissingBean注解。

举例说明，让我们将一个entityManagerFactory bean 添加到我们的配置类中，并指定如果存在一个名为dataSource的bean 并且尚未定义一个名为entityManagerFactory的 bean，我们就创建这个bean ：

@Bean
@ConditionalOnBean(name = "dataSource")
@ConditionalOnMissingBean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
final LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
em.setDataSource(dataSource());
em.setPackagesToScan("com.peterwanghao.samples.springboot.autoconfiguration.example");
em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
if (additionalProperties() != null) {
em.setJpaProperties(additionalProperties());
}
return em;
}

让我们配置一个只在尚未定义类型为JpaTransactionManager的bean时才会加载的transactionManager bean ：

@Bean
@ConditionalOnMissingBean(type = "JpaTransactionManager")
JpaTransactionManager transactionManager(final EntityManagerFactory entityManagerFactory) {
final JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory(entityManagerFactory);
return transactionManager;
}
3.3 基于属性的条件注解
@ConditionalOnProperty注解用于指定是否配置将基于Spring环境属性的存在和值被加载。

首先，让我们为配置添加一个属性源文件，以确定从哪里读取属性：

@PropertySource("classpath:mysql.properties")
public class MySQLAutoconfiguration {
//...
}

我们可以配置主DataSource bean，它将用于创建与数据库的连接，只有在存在名为usemysql的属性时才会加载它。

我们可以使用属性havingValue来指定必须匹配的usemysql属性的某些值。

如果usemysql属性设置为local，让我们使用默认值定义dataSource bean，该默认值连接到名为myDb的本地数据库：

@Bean
@ConditionalOnProperty(name = "usemysql", havingValue = "local")
@ConditionalOnMissingBean
public DataSource dataSource() {
final DriverManagerDataSource dataSource = new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/myDb?createDatabaseIfNotExist=true&&serverTimezone=GMT%2B8");
dataSource.setUsername("root");
dataSource.setPassword("123456");

return dataSource;
}

如果usemysql属性设置为自定义，则数据源 bean将使用自定义属性值的数据库URL，用户和密码进行配置：

@Bean(name = "dataSource")
@ConditionalOnProperty(name = "usemysql", havingValue = "custom")
@ConditionalOnMissingBean
public DataSource dataSource2() {
final DriverManagerDataSource dataSource = new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl(env.getProperty("mysql.url"));
dataSource.setUsername(env.getProperty("mysql.user") != null ? env.getProperty("mysql.user") : "");
dataSource.setPassword(env.getProperty("mysql.pass") != null ? env.getProperty("mysql.pass") : "");

return dataSource;
}

该mysql.properties文件将包含usemysql属性：

usemysql=local
1
如果使用MySQLAutoconfiguration的应用程序希望覆盖默认属性，则它需要做的就是为mysql.properties文件中的mysql.url，mysql.user和mysql.pass属性添加不同的值以及添加usemysql = custom行。

3.4 基于资源的条件注解
添加@ConditionalOnResource注解意味着仅在存在指定资源时才加载配置。

让我们定义一个名为additionalProperties（）的方法，该方法将返回一个Properties对象，该对象包含entityManagerFactory bean 使用的特定于Hibernate的属性，仅当存在资源文件mysql.properties时：

@ConditionalOnResource(resources = "classpath:mysql.properties")
@Conditional(HibernateCondition.class)
final Properties additionalProperties() {
final Properties hibernateProperties = new Properties();

hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("mysql-hibernate.hbm2ddl.auto"));
hibernateProperties.setProperty("hibernate.dialect", env.getProperty("mysql-hibernate.dialect"));
hibernateProperties.setProperty("hibernate.show_sql",
env.getProperty("mysql-hibernate.show_sql") != null ? env.getProperty("mysql-hibernate.show_sql")
: "false");

return hibernateProperties;
}

我们可以将Hibernate特定的属性添加到mysql.properties文件中：

mysql-hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
mysql-hibernate.show_sql=true
mysql-hibernate.hbm2ddl.auto=create-drop

3.5 自定义条件
如果我们不想使用Spring Boot中的任何可用条件，我们还可以通过扩展SpringBootCondition类并重写getMatchOutcome（）方法来定义自定义条件。

让我们为additionalProperties（）方法创建一个名为HibernateCondition的条件，该方法将验证类路径上是否存在HibernateEntityManager类：

static class HibernateCondition extends SpringBootCondition {

private static final String[] CLASS_NAMES = { "org.hibernate.ejb.HibernateEntityManager",
"org.hibernate.jpa.HibernateEntityManager" };

@Override
public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
ConditionMessage.Builder message = ConditionMessage.forCondition("Hibernate");

return Arrays.stream(CLASS_NAMES)
.filter(className -> ClassUtils.isPresent(className, context.getClassLoader()))
.map(className -> ConditionOutcome.match(message.found("class").items(Style.NORMAL, className)))
.findAny().orElseGet(() -> ConditionOutcome.noMatch(
message.didNotFind("class", "classes").items(Style.NORMAL, Arrays.asList(CLASS_NAMES))));
}

}

然后我们可以将条件添加到additionalProperties（）方法：

@Conditional(HibernateCondition.class)
Properties additionalProperties() {
//...
}

3.6 申请条件
我们还可以通过添加@ConditionalOnWebApplication或@ConditionalOnNotWebApplication注释来指定只能在Web上下文内部/外部加载配置。

4. 测试自动配置
让我们创建一个非常简单的例子来测试我们的自动配置。我们将使用Spring Data 创建一个名为MyUser的实体类和一个MyUserRepository接口：

@Entity
public class MyUser {
@Id
private String email;

public MyUser() {
}

public MyUser(String email) {
super();
this.email = email;
}

public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

}

public interface MyUserRepository extends JpaRepository<MyUser, String> {

}
1
2
3
要启用自动配置，我们可以使用@SpringBootApplication或@EnableAutoConfiguration注解：

@SpringBootApplication
public class AutoconfigurationApplication {

public static void main(String[] args) {
SpringApplication.run(AutoconfigurationApplication.class, args);
}
}

接下来，让我们编写一个保存MyUser实体的JUnit测试：

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = AutoconfigurationApplication.class)
@EnableJpaRepositories(basePackages = { "com.peterwanghao.samples.springboot.autoconfiguration.example" })
public class AutoconfigurationLiveTest {

@Autowired
private MyUserRepository userRepository;

@Test
public void whenSaveUser_thenOk() {
MyUser user = new MyUser("user@email.com");
userRepository.save(user);
}

}

由于我们尚未定义DataSource配置，因此应用程序将使用我们创建的自动配置连接到名为myDb的MySQL数据库。

连接字符串包含createDatabaseIfNotExist = true属性，因此数据库不需要存在。但是，需要创建用户mysqluser或通过mysql.user属性指定的用户mysqluser。

我们可以检查应用程序日志，看看是否正在使用MySQL数据源：

10:31:47.092 [main] INFO org.hibernate.Version - HHH000412: Hibernate Core {5.3.7.Final}
10:31:47.094 [main] INFO org.hibernate.cfg.Environment - HHH000206: hibernate.properties not found
10:31:47.227 [main] INFO o.h.annotations.common.Version - HCANN000001: Hibernate Commons Annotations {5.0.4.Final}
10:31:48.039 [main] INFO org.hibernate.dialect.Dialect - HHH000400: Using dialect: org.hibernate.dialect.MySQL5InnoDBDialect
Hibernate: drop table if exists MyUser
Hibernate: create table MyUser (email varchar(255) not null, primary key (email)) engine=InnoDB
10:31:48.655 [main] INFO o.h.t.s.internal.SchemaCreatorImpl - HHH000476: Executing import script 'org.hibernate.tool.schema.internal.exec.ScriptSourceInputNonExistentImpl@3a0b6a'
10:31:48.666 [main] INFO o.s.o.j.LocalContainerEntityManagerFactoryBean - Initialized JPA EntityManagerFactory for persistence unit 'default'
10:31:49.496 [main] INFO o.s.s.c.ThreadPoolTaskExecutor - Initializing ExecutorService 'applicationTaskExecutor'
10:31:49.569 [main] WARN o.s.b.a.o.j.JpaBaseConfiguration$JpaWebConfiguration$JpaWebMvcConfiguration - spring.jpa.open-in-view is enabled by default. Therefore, database queries may be performed during view rendering. Explicitly configure spring.jpa.open-in-view to disable this warning
10:31:49.701 [main] WARN o.s.b.a.t.ThymeleafAutoConfiguration$DefaultTemplateResolverConfiguration - Cannot find template location: classpath:/templates/ (please add some templates or check your Thymeleaf configuration)
10:31:50.091 [main] INFO c.p.s.s.a.AutoconfigurationLiveTest - Started AutoconfigurationLiveTest in 4.803 seconds (JVM running for 5.519)
Hibernate: select myuser0_.email as email1_0_0_ from MyUser myuser0_ where myuser0_.email=?
Hibernate: insert into MyUser (email) values (?)
10:31:50.279 [Thread-2] INFO o.s.s.c.ThreadPoolTaskExecutor - Shutting down ExecutorService 'applicationTaskExecutor'
10:31:50.281 [Thread-2] INFO o.s.o.j.LocalContainerEntityManagerFactoryBean - Closing JPA EntityManagerFactory for persistence unit 'default'
10:31:50.282 [Thread-2] INFO o.h.t.s.i.SchemaDropperImpl$DelayedDropActionImpl - HHH000477: Starting delayed evictData of schema as part of SessionFactory shut-down'
Hibernate: drop table if exists MyUser

5. 禁用自动配置类
如果我们想要从加载中排除自动配置，我们可以将带有exclude或excludeName属性的@EnableAutoConfiguration注解添加到配置类：

@Configuration
@EnableAutoConfiguration(
exclude={MySQLAutoconfiguration.class})
public class AutoconfigurationApplication {
//...
}

禁用特定自动配置的另一个方法是设置spring.autoconfigure.exclude属性：

spring.autoconfigure.exclude=com.peterwanghao.samples.springboot.autoconfiguration.MySQLAutoconfiguration

总结

SpringBoot 的 自动配置得益于 SpringFramework 强大的支撑，框架早已有很多工具和注解可以自动装配 Bean 。SpringBoot 通过 一个封装，将市面上通用的组件直接写好了配置类。当我们程序去依赖了这些组件的 jar 包后，启动 SpringBoot应用，于是自动加载开始了。

我们也可以定义自己的自动装配组件，依赖之后，Spring直接可以加载我们定义的 starter 。笔者将在后续文章中进行编码和解读。