SpringBoot自动配置的魔法是怎么实现的

SpringBoot 最重要的功能就是自动配置，帮我们省去繁琐重复地配置工作。相信用过SpringBoot的人，都会被它简洁的步骤所惊讶。那么 SpringBoot 是如何实现自动配置的呢？

在这之前，我们需要了解Spring的@Conditional注解特性，SpringBoot的自动配置魔法正是基于此实现的。

探寻@Conditional的魔力

当开发基于Spring的应用时，我们可能会选择性的注册Bean。

比如说，当程序运行在本地的时候，你可能会注册一个DataSource Bean指向dev数据库。 当程序运行在生产环境时，将DataSource Bean指向一个生产库。

你可以将数据库连接参数抽取到properties文件中，并在恰当的环境中使用这个properties文件。但是当你想连接另外一个数据库环境时，你需要修改properties文件配置。

为了处理这个问题，Spring 3.1提出来Profiles概念。你可以注册多个相同类型的Bean，并用一个或多个profiles文件关联。当你运行程序时，你可以激活需要的profiles文件以及与激活的profiles文件关联的beans，并且只有这些profiles会被激活。


@Configuration
public class AppConfig
{
@Bean
@Profile("DEV")
public DataSource devDataSource() {
...
}
@Bean
@Profile("PROD")
public DataSource prodDataSource() {
...
}
}


通过系统参数 -Dspring.profiles.active=DEV，你可以指定需要激活的profile。

对于简单的情况，比如通过激活的profile开启或者关闭bean的注册，这种方式很好用。但是如果你想通过一些逻辑判断来注册bean，那么这种方式就不那么有效了。

为了更灵活地注册Spring beans，Spring 4提出了@Conditional概念。通过使用@Conditional，你可以根据任何条件选择性地注册bean。

例如，你可以根据下面这些条件来注册bean：

• 当classpath中存在这个指定的类时
• 当ApplicationContext中不存在这个指定的Spring bean时
• 当一个指定的文件存在时
• 当配置文件中一个指定的属性配置了时
• 当一个指定的系统属性存在或者不存在时

上面仅仅只是一个很小的例子，你可以制定任何你想要的规则。

我们一起来看看Spring的@Conditional究竟是怎么工作的。

假设我们有一个UserDAO接口，并有一个从数据库获取数据的方法。我们有两个UserDAO接口实现类，一个叫JdbcUserDAO，连接MySQL 数据库。另一个叫MongoUserDAO，连接MongoDB。

我们可能启用JdbcUserDAO和MongoUserDAO中的一个接口，通过系统属性dbType。

如果应用通过java -jar myapp.jar -DdbType=MySQL命令启动，那么将启用JdbcUserDAO。否则，应用通过java -jar myapp.jar -DdbType=MONGO命令启动，那么将启用MongoUserDAO。

UserDAO，JdbcUserDAO和MongoUserDAO的代码如下：

public interface UserDAO {
List<String> getAllUserNames();
}public class JdbcUserDAOImpl implements UserDAO {
@Override
public List<String> getAllUserNames() {
System.out.println("**** Getting usernames from RDBMS *****");
return Arrays.asList("Siva","Prasad","Reddy");
}
}public class MongoUserDAOImpl implements UserDAO {
@Override
public List<String> getAllUserNames() {
System.out.println("**** Getting usernames from MongoDB *****");
return Arrays.asList("Bond","James","Bond");
}
}


实现Condition接口的MySQLDatabaseTypeCondition类，用来检查系统属性dbType是MySQL，代码如下：

public class MySQLDatabaseTypeCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext,
AnnotatedTypeMetadata annotatedTypeMetadata) {
String enabledDBType = System.getProperty("dbType");
return "MySQL".equalsIgnoreCase(enabledDBType);
}
}


同样地，为了检查系统属性dbType是MongoDB，MongoDBDatabaseTypeCondition类的实现如下：

public class MongoDBDatabaseTypeCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext,
AnnotatedTypeMetadata annotatedTypeMetadata) {
String enabledDBType = System.getProperty("dbType");
return "MongoDB".equalsIgnoreCase(enabledDBType);
}
}


现在我们可以通过@Conditional选择性地配置JdbcUserDAO和MongoUserDAO。如下：

@Configuration
public class AppConfig
{
@Bean
@Conditional(MySQLDatabaseTypeCondition.class)
public UserDAO jdbcUserDAO(){
return new JdbcUserDAO();
}
@Bean
@Conditional(MongoDBDatabaseTypeCondition.class)
public UserDAO mongoUserDAO(){
return new MongoUserDAO();
}
}


如果我们运行程序类似于java -jar myapp.jar -DdbType=MYSQL这样，那么只有JdbcUserDAO会被注册。如果运行程序类似于java -jar myapp.jar -DdbType=MONGODB这样，那么只有MongoUserDAO会被注册。

到目前为止，我们知道了如何通过System Property属性选择性地注册bean。

假设我们想只有当MongoDB的驱动类"com.mongodb.Server"可以在类路径下获取时，才注册MongoUserDAO，否则注册JdbcUserDAO。

为了实现这个目的，我们可以创建一个类去检查MongoDB驱动类"com.mongodb.Server"是否存在，代码如下：

public class MongoDriverPresentsCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata)
{
try {
Class.forName("com.mongodb.Server");
return true;
} catch (ClassNotFoundException e) {
return false;
}
}
}public class MongoDriverNotPresentsCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata)
{
try {
Class.forName("com.mongodb.Server");
return false;
} catch (ClassNotFoundException e) {
return true;
}
}
}


刚刚我们实现了基于是否一个类在类路径中来注册bean的方法。

如果要实现只有Spring中没有UserDAO类型的bean时，才注册MongoUserDAO，要该怎么做？

我们可以创建一个Condition类去检查是否一个指定类型的bean已经存在，具体如下：

public class UserDAOBeanNotPresentsCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata) {
UserDAO userDAO = conditionContext.getBeanFactory().getBean(UserDAO.class);
return (userDAO == null);
}
}


如果要实现只有当属性app.dbType=MONGO在配置文件中被设置时，才注册MongoUserDAO，要该怎么做？

我们可以这样实现：

public class MongoDbTypePropertyCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata) {
String dbType = conditionContext.getEnvironment().getProperty("app.dbType");
return "MONGO".equalsIgnoreCase(dbType);
}
}


我们已经举了很多例子去实现条件注册。但是，通过使用注解还有一种更优雅地方式去实现条件注册。我们创建一个 @DatabaseType 注解，而不用为MySQL和MongoDB都实现Condition类，如下：

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Conditional(DatabaseTypeCondition.class)
public @interface DatabaseType {
String value();
}


然后我们可以实现DatabaseTypeCondition类，使用 @DatabaseType 的value值来判断是否注册。代码如下：

public class DatabaseTypeCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext,
AnnotatedTypeMetadata annotatedTypeMetadata) {
Map<String, Object> annotationAttributes = annotatedTypeMetadata
.getAnnotationAttributes(DatabaseType.class.getCanonicalName());
if (annotationAttributes == null) {
return false;
}
String type = (String) annotationAttributes.get("value");
String enabledType = System.getProperty("dbType", "MySQL");
return type != null && type.equalsIgnoreCase(enabledType);
}
}


现在我们可以使用 @DatabaseType 来配置我们的bean，具体如下：

@Configuration
@ComponentScan
public class AppConfig {
@Bean
@DatabaseType("MYSQL")
public UserDAO jdbcUserDAO(){
return new JdbcUserDAOImpl();
}
@Bean
@DatabaseType("MONGO")
public UserDAO mongoUserDAO(){
return new MongoUserDAOImpl();
}
}


这里我们从 @DatabaseType 注解中获取元数据，并与系统属性dbType比较，从而决定是否注册bean。

我们已经通过许多例子来理解如何通过 @Conditional 来控制bean的注册。

SpringBoot中广泛地使用 @Conditional 特性来进行条件注册。

你可以在spring-boot-autoconfigure-{version}.jar的org.springframework.boot.autoconfigure包下找到各种各样的Condition实现类。

至此，我们知道了SpringBoot如何使用 @Conditional 特性来选择性地注册bean，但是自动配置机制是如何触发的呢？

我们接着往下看。

Spring Boot 自动配置

Spring Boot 自动配置魔法的关键是 @EnableAutoConfiguration 注解。

通常我们使用 @SpringBootApplication 来注解一个应用的入口类，也可以使用以下注解来定义：

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application{}


@EnableAutoConfiguration注解能够开启Spring ApplicationContext 的自动配置功能，通过扫描类路径下的组件并注册符合条件的bean。

SpringBoot 在spring-boot-autoconfigure-{version}.jar中提供了各种各样的AutoConfiguration类，负责注册各种各样的组件。

通常，AutoConfiguration 类被 @Configuration 注解，表明这是一个Spring 的配置类。如果被 @EnableConfigurationProperties 注解，则可以绑定自定义的属性。

例如，org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration类：

@Configuration
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class,
DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {@Configuration
@Conditional(EmbeddedDatabaseCondition.class)
@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
@Import(EmbeddedDataSourceConfiguration.class)
protected static class EmbeddedDatabaseConfiguration {}@Configuration
@Conditional(PooledDataSourceCondition.class)
@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
@Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.Generic.class,
DataSourceJmxConfiguration.class })
protected static class PooledDataSourceConfiguration {}...
...
}


DataSourceAutoConfiguration上注解着 @ConditionalOnClass({ DataSource.class,EmbeddedDatabaseType.class }) ，说明只有在DataSource.class和EmbeddedDatabaseType.class类在类路径下可获得的情况下，自动配置才会生效。

同时，这个类上面还注解着 @EnableConfigurationProperties(DataSourceProperties.class)，也就是说它能够自动地将application.properties中的属性绑定到DataSourceProperties类上的属性。

@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean {
...
...
private String driverClassName;
private String url;
private String username;
private String password;
... // setters and getters
...
}


配置文件中所有以 spring.datasource.* 开头的属性都会自动绑定到 DataSourceProperties对象上。

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.jdbc.Driver


你可能还会看到一些其他的条件注解，例如 @ConditionalOnMissingBean， @ConditionalOnClass 和 @ConditionalOnProperty 等等。

只有这些条件满足时，bean才会被注册到ApplicationContext 。

在spring-boot-autoconfigure-{version}.jar中能找到许多其他的自动配置类，例如：

• org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration
• org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration
• org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration
• org.springframework.boot.autoconfigure.jackson.JacksonAutoConfigurationetc 等等。

一句话总结下来就是，SpringBoot通过 @Conditional 以及各种各样的自动配置类实现SpringBoot的自动配置机制。