1. 概述

简单地说，Spring boot自动配置帮助我们根据类路径上存在的依赖项自动配置 Spring 应用程序。

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

2. Maven 依赖项

让我们从依赖项开始：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</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 {
    //...
}

接下来，我们需要将类注册为自动配置候选项。

为此，我们将类的名称添加到标准文件资源/META-INF/spring.factory 中的键 org.springframework.boot.autoconfigure.EnableAutoConfiguration 下：

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

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

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

请注意，仅当我们不在应用程序中定义自动配置的 bean 时，自动配置才会生效。如果我们定义我们的 bean，它将覆盖默认的 bean。

3.1. Class Conditions

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

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

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

3.2. Bean Conditions

如果我们想仅在指定的 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.3. Property Conditions

我们使用 @ConditionalOnProperty 注解来指定是否根据 Spring 环境属性的存在和值加载配置。

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

@PropertySource("classpath:mysql.properties")
public class MySQLAutoconfiguration {
    //...
}

我们可以配置用于创建与数据库的连接的主 DataSource Bean，以便仅在存在名为 usemysql 的属性时才加载它。

我们可以使用属性 havingValue 来指定必须匹配的 usemysql 属性的某些值。

现在，让我们使用默认值定义数据源 bean ，如果我们将 usemysql 属性设置为 local ，则这些默认值连接到名为 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 ，我们将使用数据库 URL、用户名和密码的自定义属性值来配置 dataSource bean：

@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 line 添加不同的值。

3.4. Resource Conditions

添加 @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

3.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() {
  //...
}

3.6. Application Conditions

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

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 AutoconfigurationLiveTest {

    @Autowired
    private MyUserRepository userRepository;

    @Test
    public void whenSaveUser_thenOk() {
        MyUser user = new MyUser("user@email.com");
        userRepository.save(user);
    }
}

由于我们没有定义数据源配置，因此应用程序将使用我们创建的自动配置连接到名为 myDB 的 MySQL 数据库。

连接字符串包含 createDatabaseIfNotExist=true 属性，因此数据库不需要存在。但是，需要创建用户 mysqluser，或者通过 mysql.user 属性指定的用户（如果存在）。

我们可以检查应用程序日志以查看我们使用的是 MySQL 数据源：

web - 2026-03-16T08:07:02+00:00,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自动配置怎么实现的)