使用SpringBoot自定义配置文件

1.概述

简单地说，Spring Boot 自动配置代表了一种基于类路径中存在的依赖项自动配置 Spring 应用程序的方法。

通过消除定义自动配置类中包含的某些 bean 的需要，这可以使开发更快、更容易。

2.Maven依赖

让我们从我们需要的Maven依赖项开始：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <version>2.4.0</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.19</version>
</dependency>

最新版本的spring-boot-starter-data-jpa和mysql-connector-java可以从 Maven Central 下载。

3.创建自定义自动配置

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

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

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

下一个强制性步骤是将类注册为自动配置候选者，方法是在标准文件resources/META-INF/spring.factories中的键org.springframework.boot.autoconfigure.EnableAutoConfiguration下添加类的名称：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.baeldung.autoconfiguration.MySQLAutoconfiguration

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

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

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

(1)班级条件

类条件允许我们使用@ConditionalOnClass注解指定如果指定的类存在，或者使用@ConditionalOnMissingClass注解不存在类，则将包含配置 bean。

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

@Configuration
@ConditionalOnClass(DataSource.class)
public class MySQLAutoconfiguration {
    //...
}

(2)bean条件

如果我们只想在指定的 bean 存在或不存在时才包含 bean，我们可以使用@ConditionalOnBean和@ConditionalOnMissingBean注释。

为了举例说明这一点，让我们在配置类中添加一个entityManagerFactory bean，并指定我们只希望在存在名为dataSource的 bean 并且尚未定义名为entityManagerFactory的 bean 时创建此 bean：

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

让我们还配置一个transactionManager bean，仅当JpaTransactionManager类型的 bean尚未定义时才会加载：

@Bean
@ConditionalOnMissingBean(type = "JpaTransactionManager")
JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
    JpaTransactionManager transactionManager = new JpaTransactionManager();
    transactionManager.setEntityManagerFactory(entityManagerFactory);
    return transactionManager;
}

(3)条件

@ConditionalOnProperty注释用于指定是否将基于 Spring Environment 属性的存在和值来加载配置。

首先，让我们为我们的配置添加一个属性源文件，该文件将确定从何处读取属性：

@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() {
    DriverManagerDataSource dataSource = new DriverManagerDataSource(); 
    dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/myDb?createDatabaseIfNotExist=true");
    dataSource.setUsername("mysqluser");
    dataSource.setPassword("mysqlpass");
    return dataSource;
}

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

@Bean(name = "dataSource")
@ConditionalOnProperty(
  name = "usemysql", 
  havingValue = "custom")
@ConditionalOnMissingBean
public DataSource dataSource2() {
    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

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

(4)资源条件

添加@ConditionalOnResource注解意味着只有在指定资源存在时才会加载配置。

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

@ConditionalOnResource(
  resources = "classpath:mysql.properties")
@Conditional(HibernateCondition.class)
Properties additionalProperties() {
    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.MySQLDialect
mysql-hibernate.show_sql=true
mysql-hibernate.hbm2ddl.auto=create-drop

(5)自定义条件

如果我们不想使用 Spring Boot 中可用的任何条件，我们还可以通过扩展SpringBootCondition类并覆盖getMatchOutcome()方法来定义自定义条件。

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

static class HibernateCondition extends SpringBootCondition {
    private static 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() {
  //...
}

(6)申请条件

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

4.测试自动配置

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

@Entity
public class MyUser {
    @Id
    private String email;
    // standard constructor, getters, setters
}

public interface MyUserRepository 
  extends JpaRepository<MyUser, String> { }

要启用自动配置，我们可以使用@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.baeldung.autoconfiguration.example" })
public class AutoconfigurationTest {
    @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属性指定的用户(如果存在)。

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

web - 2017-04-12 00:01:33,956 [main] INFO  o.s.j.d.DriverManagerDataSource - Loaded JDBC driver: com.mysql.cj.jdbc.Driver

5.禁用自动配置类

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

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

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

spring.autoconfigure.exclude=com.baeldung.autoconfiguration.MySQLAutoconfiguration

以上就是关于“使用SpringBoot自定义配置文件”的介绍，如果大家想了解更多相关知识，可以关注一下动力节点的SpringBoot教程，教程内容从浅到深，通俗易懂，适合小白学习，希望对大家能够有所帮助。