Spring Boot自动配置如何工作

通过使用Mongo和MySQL DB实现的示例，深入了解Spring Boot的@Conditional注释世界。

在我以前的文章“为什么选择Spring Boot?”中，我们讨论了如何创建Spring Boot应用程序，但是你可能了解也可能不了解幕后情况。 你可能想了解Spring Boot自动配置背后的魔力。

在此之前，你应该了解Spring的@Conditional功能，所有Spring Boot的AutoConfiguration魔术都依赖于此。

 

探索@Conditional的力量

在开发基于Spring的应用程序时，我们可能会遇到有条件地注册bean的需求。

例如，你可能想在本地运行应用程序时注册一个指向dev数据库的DataSource bean，而在生产环境中运行时则指向一个不同的生产数据库。

你可以将数据库连接参数外部化到属性文件中，并使用适合该环境的文件，但是每当需要指向其他环境并构建应用程序时，都需要更改配置。

为了解决这个问题，Spring 3.1引入了Profiles的概念。 你可以注册多个相同类型的bean，并将它们与一个或多个概要文件关联。 运行应用程序时，你可以激活所需的配置文件以及与已激活的配置文件相关联的Bean，并且只有那些配置文件将被注册。

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

 

然后，你可以使用系统属性-Dspring.profiles.active=DEV指定活动配置文件。

这种方法适用于简单情况，例如根据已激活的配置文件启用或禁用bean注册。但是，如果你要基于某些条件逻辑来注册bean，那么概要文件方法本身是不够的。

为了为有条件地注册Spring Bean提供更大的灵活性，Spring 4引入了@Conditional的概念。通过使用@Conditional方法，你可以根据任意条件有条件地注册bean。

例如，在以下情况下，你可能想要注册一个bean：

• 类路径中存在特定的类
• 某些类型的Spring bean尚未在ApplicationContext中注册
• 某个位置上存在特定文件
• 在配置文件中配置了特定的属性值
• 存在/不存在特定的系统属性

这些仅是几个示例，你可以具有所需的任何条件。

让我们看一下Spring的@Conditional的工作原理。

假设我们有一个UserDAO接口，其中包含从数据存储中获取数据的方法。我们有两种UserDAO接口的实现，即与MySQL数据库对话的JdbcUserDAO和与MongoDB对话的MongoUserDAO。

我们可能只想基于系统属性（即dbType）启用JdbcUserDAO和MongoUserDAO的一个接口。

如果使用java -jar myapp.jar -DdbType = MySQL启动应用程序，那么我们要启用JdbcUserDAO。否则，如果使用java -jar myapp.jar -DdbType = MONGO启动了应用程序，则我们要启用MongoUserDAO。

假设我们有一个UserDAO bean和一个JdbcUserDAO bean。 MongoUserDAO实现如下：

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

 

我们可以实现条件MySQLDatabaseTypeCondition来检查系统属性dbType是否为“ MYSQL”，如下所示：

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

 

我们可以实现条件MongoDBDatabaseTypeCondition来检查系统属性dbType是否为“ MONGODB”，如下所示：

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

 

现在，我们可以使用@Conditional有条件地配置JdbcUserDAO和MongoUserDAO Bean，如下所示：

@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 Bean。但是，如果将系统属性设置为-DdbType = MONGODB，则只会注册MongoUserDAO Bean。

现在，我们已经看到了如何基于系统属性有条件地注册bean。

假设仅当classpath上有MongoDB Java驱动程序类“ com.mongodb.Server”可用时，我们才想注册MongoUserDAO Bean，否则，我们希望注册JdbcUserDAO Bean。

为此，我们可以创建条件来检查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。

如果仅当尚未注册其他类型为UserDAO的Spring Bean时才想注册MongoUserDAO Bean，该怎么办？

我们可以创建一个条件来检查是否存在某种特定类型的现有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 bean，该怎么办？

我们可以如下实现该条件：

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

 

我们刚刚看到了如何实现各种类型的条件，但是还有使用注释来实现条件的更优雅的方法。 代替为MYSQL和MongoDB创建Condition实现，我们可以创建如下的DatabaseType批注：

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

 

然后，我们可以实现DatabaseTypeCondition以使用DatabaseType值来确定是启用还是禁用bean注册，如下所示：

public class DatabaseTypeCondition implements Condition
{
 @Override
 public boolean matches(ConditionContext conditionContext,
 AnnotatedTypeMetadata metadata)
 {
 Map<String, Object> attributes = metadata.getAnnotationAttributes(DatabaseType.class.getName());
 String type = (String) attributes.get("value");
 String enabledDBType = System.getProperty("dbType","MYSQL");
 return (enabledDBType != null && type != null && enabledDBType.equalsIgnoreCase(type));
 }
}

 

现在，我们可以在bean定义上使用@DatabaseType批注，如下所示：

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

 

在这里，我们从DatabaseType批注中获取元数据，并对照System Property dbType值进行检查，以确定是启用还是禁用Bean注册。

我们已经看到了很多示例，以了解如何使用@Conditional批注有条件地注册bean。

Spring Boot广泛使用@Conditional功能根据各种条件有条件地注册bean。

你可以在spring-boot-autoconfigure- {version} .jar的org.springframework.boot.autoconfigure包中找到SpringBoot使用的各种Condition实现。

现在我们已经知道了Spring Boot如何使用@Conditional功能有条件地检查是否注册Bean，但是究竟是什么触发了自动配置机制呢？

这就是我们将在下一部分中讨论的内容。

Spring Boot自动配置

Spring Boot自动配置魔术的关键是@EnableAutoConfiguration批注。通常，我们使用@SpringBootApplication注释应用程序入口点类，或者，如果要自定义默认值，可以使用以下注释：

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application
{
}

 

@EnableAutoConfiguration批注通过扫描类路径组件并注册与各种条件匹配的bean来启用Spring ApplicationContext的自动配置。

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

通常，AutoConfiguration类使用@Configuration注释，以将其标记为Spring配置类，并使用@EnableConfigurationProperties注释，以绑定定制属性和一个或多个条件Bean注册方法。

例如，考虑org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration类。

@Configuration
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })
public class DataSourceAutoConfiguration 
{
 ...
 ...
 @Conditional(DataSourceAutoConfiguration.EmbeddedDataSourceCondition.class)
 @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
 @Import(EmbeddedDataSourceConfiguration.class)
 protected static class EmbeddedConfiguration {
 }
 @Configuration
 @ConditionalOnMissingBean(DataSourceInitializer.class)
 protected static class DataSourceInitializerConfiguration {
 @Bean
 public DataSourceInitializer dataSourceInitializer() {
 return new DataSourceInitializer();
 }
 }
 @Conditional(DataSourceAutoConfiguration.NonEmbeddedDataSourceCondition.class)
 @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
 protected static class NonEmbeddedConfiguration {
 @Autowired
 private DataSourceProperties properties;
 @Bean
 @ConfigurationProperties(prefix = DataSourceProperties.PREFIX)
 public DataSource dataSource() {
 DataSourceBuilder factory = DataSourceBuilder
 .create(this.properties.getClassLoader())
 .driverClassName(this.properties.getDriverClassName())
 .url(this.properties.getUrl()).username(this.properties.getUsername())
 .password(this.properties.getPassword());
 if (this.properties.getType() != null) {
 factory.type(this.properties.getType());
 }
 return factory.build();
 }
 }
 ...
 ...
 @Configuration
 @ConditionalOnProperty(prefix = "spring.datasource", name = "jmx-enabled")
 @ConditionalOnClass(name = "org.apache.tomcat.jdbc.pool.DataSourceProxy")
 @Conditional(DataSourceAutoConfiguration.DataSourceAvailableCondition.class)
 @ConditionalOnMissingBean(name = "dataSourceMBean")
 protected static class TomcatDataSourceJmxConfiguration {
 @Bean
 public Object dataSourceMBean(DataSource dataSource) {
 ....
 ....
 }
 }
 ...
 ...
}

 

在这里，DataSourceAutoConfiguration带有@ConditionalOnClass（{DataSource.class，EmbeddedDatabaseType.class}）注释，这意味着仅当在类路径上有DataSource.class和EmbeddedDatabaseType.class类时，才会考虑DataSourceAutoConfiguration中的bean的AutoConfiguration。

该类还带有@EnableConfigurationProperties（DataSourceProperties.class）批注，该启用了自动将application.properties中的属性绑定到DataSourceProperties类的属性的功能。

@ConfigurationProperties(prefix = DataSourceProperties.PREFIX)
public class DataSourceProperties implements BeanClassLoaderAware, EnvironmentAware, InitializingBean {
 public static final String PREFIX = "spring.datasource";
 ...
 ...
 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

 

你还可以看到一些内部类和bean定义方法，这些内部类和bean定义方法用SpringBoot的条件注释（例如@ ConditionalOnMissingBean，@ ConditionalOnClass和@ConditionalOnProperty等）进行注释。

仅当这些条件匹配时，这些Bean定义才会在ApplicationContext中注册。

你还可以在spring-boot-autoconfigure- {version} .jar中探索许多其他AutoConfiguration类，例如：

• 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 etc. 

我希望你现在可以通过使用各种AutoConfiration类以及@Conditional功能来了解Spring Boot自动配置的工作方式。

感谢阅读！