SpringAutoConfiguration解密[譯]

xumingmingv發表於2016-12-13
Spring解密

本文是http://sivalabs.in/2016/03/how-springboot-autoconfiguration-magic/的翻譯。

我們知道SpringBoot的應用可以以非常簡潔的程式碼去做很多的事情, 可以自動幫你注入資料庫的Bean，訊息佇列的Bean等等等等，那麼SpringBoot是怎麼做到的呢？

但是在探索SpringBoot的神祕之前，我們先了解一下Spring的@Conditional註解，這是SpringBoot的AutoConfiguration的神奇之處所依賴的底層機制。

@Conditional 探祕

我們開發Spring應用的時候有時候會碰到要根據外界條件註冊不同Bean的情況。

比如如果你的應用是跑在本地機器的話，你會想要讓你的DataSource bean指向一個本地的資料庫，而如果是跑線上上機器的話，你會想讓DataSource bean指向一個生產的資料庫。

你可以把這些資料庫連線資訊抽取到幾個不同的配置檔案裡面去，然後在不同的環境下使用不同的配置檔案。但是當你的應用被部署到新的環境下的時候，你還是要新增新的配置檔案，並且重新打包。(譯者注:這裡其實只要把配置檔案抽取到程式碼之外不就好了麼?不知道原作者在想什麼)

為了解決這個問題，Spring 3.1引入了Profiles的概念。你可以註冊同一個型別bean的不同例項，然後把這些不同的例項繫結到不同的Profile, 當你執行這個Spring應用的時候，你可以指定你要啟用的Profile, 這樣只有跟這些被啟用的Profile相關聯的bean才會被註冊:

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

    @Bean
    @Profile("PROD")
    public DataSource prodDataSource() {
        ...
    }
}

然後你可以通過系統屬性指定啟用的profile:

-Dspring.profiles.active=DEV

這種方式對於你要基於profile來決定是否註冊一個bean的情況工作得很好。但是如果你要基於一些條件性的判斷邏輯來決定是否註冊一個bean的話，那麼光靠profile是不行的。

為了給條件性地註冊bean提供更高的靈活性，Spring 4提供了@Conditional的概念。通過使用@Conditional你可以基於任何條件來決定是否註冊一個bean。

你的條件可能是這樣的:

  • CLASSPATH裡面有一個特定的Class
  • ApplicationContext裡面有一個特定型別的bean
  • 在指定的位置有指定的檔案
  • 配置檔案裡面有指定的配置項
  • 系統屬性裡面配置了指定的屬性

這些只是我能想到的一些，實際上你可以基於任何條件。下面讓我們來看看Spring的@Conditional到底是如何工作的。我們先設定一個場景:

我們有一個UserDAO介面用來從資料庫裡面獲取資料。這個介面我們有兩個實現: JdbcUserDAO從MySQL資料庫裡面獲取資料；MongoUserDAO從MongoDB裡面獲取資料。

通過系統屬性來決定

我們想通過一個名為dbType的系統屬性來決定到底使用JdbcUserDAO還是MongoUserDAO。期望的效果是，如果通過java -jar myapp.jar -DdbType=MySQL那麼使用的是JdbcUserDAO, 如果通過java -jar myapp.jar -DdbType=MONGO啟動，這使用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:

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:

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

    @Bean
    @Conditional(MongoDBDatabaseTypeCondition.class)
    public UserDAO mongoUserDAO(){
        return new MongoUserDAO();
    }
}

通過CLASSPATH上是否有指定的類來判斷

類似地我們可以通過判斷CLASSPATH裡面是否有com.mongodb.Server這個Driver類來決定是使用MongoUserDAO還是JdbcUserDAO:

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的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);
    }
}

如果想通過配置檔案裡面的配置來決定DAO型別呢?

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

更優雅的實現方式: 註解

我們已經試了通過各種不同條件來實現Condition。但是其實有更優雅的、通過註解來實現Condition的方式。我們不再為MYSQL和MongoDB實現各自Condition, 我們可以實現下面這樣一個DatabaseType註解:

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

然後我們實現DatabaseTypeCondition來使用這個註解來判斷DAO的型別了:

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
{
    @Bean
    @DatabaseType("MYSQL")
    public UserDAO jdbcUserDAO(){
        return new JdbcUserDAO();
    }

    @Bean
    @DatabaseType("MONGO")
    public UserDAO mongoUserDAO(){
        return new MongoUserDAO();
    }
}

這裡我們從DatabaseType註解裡面獲取後設資料，並且把獲取的值跟系統屬性裡面的dbType進行對比來決定是否啟用bean。

我們已經看了很多例子來看@Conditional註解的作用。SpringBoot大量的使用@Conditional來實現基於條件的註冊bean。你可以在spring-boot-autoconfigure-{version}.jar 的 org.springframework.boot.autoconfigure 包裡面看到SpringBoot使用的大量的Condition的實現。

那麼我們已經知道了SpringBoot使用@Conditional來決定是否初始化一個bean, 但是是什麼機制觸發了auto-configuration機制呢？ 我們下一節來聊聊這個事情:

SprintBoot的自動配置

SpringBoot的自動配置的關鍵在於@EnableAutoConfiguration這個註解。一般來說我們把我們程式的入口類加上@SpringBootApplication註解，或者如果我們想要更加細緻的定製這些預設值的話:

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application
{

}

@EnableAutoConfiguration註解通過掃描CLASSPATH裡面所有的元件，然後基於條件來決定是否註冊bean來使得Spring的ApplicationContext自動配置。

SpringBoot在spring-boot-autoconfigure-{version}.jar裡面提供了很多AutoConfiguration的類來負責註冊各種不同的元件。

一般來說AutoConfiguration類上面會標上@Configuration註解來標明它是一個Spring的配置類，標上@EnableConfigurationProperties來繫結自定義的配置值，並且會在一到多個方法上標上@Conditional註解來標記註冊方法。

比如我們來看看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 }), 這樣只有當CLASSPATH上有DataSource.class和EmbeddedDatabaseType.class的時候，DataSourceAutoConfiguration 才會生效。

這個類還被@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的定義方法被SpringBoot的@ConditionalOnMissingBean, @ConditionOnClass, @ConditionalOnProperty等等標記。

這些bean的定義只有在那些條件滿足的時候才會註冊。

在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.JacksonAutoConfiguration

等等。我希望通過今天文章的介紹大家已經理解SpringBoot是怎麼做到自動配置bean的了。


相關文章