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的自动配置机制。

巴特西

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

探寻@Conditional的魔力

Spring Boot 自动配置

最新文章

热门文章