Spring Boot凭借其简化的配置和易用的特性，极大地提升了Java开发的效率。在Spring Boot项目中，配置文件扮演着重要的角色，它不仅定义了应用的基本参数，还决定了应用在不同环境中的行为。本文将详细介绍Spring Boot配置文件的各种使用方式和最佳实践，旨在帮助开发者全面掌握Spring Boot项目的配置文件管理。

1. Spring Boot配置文件概述

Spring Boot支持多种配置文件格式，主要包括application.properties和application.yml。这些配置文件可以定义应用的各种参数，如服务器端口、数据库连接信息、日志配置等。

1.1 application.properties文件

application.properties文件是最常见的配置文件格式，采用简单的键值对形式。其语法简单直观，易于书写和阅读。

  1. # application.properties 示例
  2. server.port=8080
  3. spring.datasource.url=jdbc:mysql://localhost:3306/mydb
  4. spring.datasource.username=root
  5. spring.datasource.password=secret

1.2 application.yml文件

application.yml文件使用YAML格式，具有更好的结构化特点，适合复杂的配置场景。YAML格式以缩进表示层级关系，语法更加简洁。

  1. # application.yml 示例
  2. server:
  3.   port: 8080
  5. spring:
  6.   datasource:
  7.     url: jdbc:mysql://localhost:3306/mydb
  8.     username: root
  9.     password: secret

2. 配置文件的加载顺序

Spring Boot支持从多个位置加载配置文件，并按照特定的顺序进行加载。理解这些加载顺序对于正确配置应用非常重要。

2.1 配置文件加载位置

Spring Boot可以从以下位置加载配置文件：

  1. application.properties或application.yml（项目根目录或src/main/resources目录）
  2. 命令行参数
  3. SPRING_APPLICATION_JSON环境变量
  4. @PropertySource注解
  5. @TestPropertySource注解（仅在测试中）

2.2 配置文件的优先级

Spring Boot按照一定的优先级加载配置文件，后加载的配置会覆盖先加载的配置。以下是加载优先级（由低到高）：

  1. 默认配置
  2. application.properties或application.yml
  3. 命令行参数
  4. SPRING_APPLICATION_JSON环境变量

3. 外部化配置

Spring Boot支持将配置外部化，使得应用在不同环境中可以轻松切换配置。外部化配置可以通过多种方式实现，包括环境变量、命令行参数和配置文件等。

3.1 环境变量

环境变量是一种常见的外部化配置方式，适用于在不同操作系统中配置应用参数。

  1. # 设置环境变量
  2. export SPRING_DATASOURCE_URL=jdbc:mysql://localhost:3306/mydb
  3. export SPRING_DATASOURCE_USERNAME=root
  4. export SPRING_DATASOURCE_PASSWORD=secret

3.2 命令行参数

命令行参数可以在应用启动时指定，适用于临时性配置或调试场景。

  1. # 使用命令行参数启动应用
  2. $ java -jar myapp.jar --spring.datasource.url=jdbc:mysql://localhost:3306/mydb --spring.datasource.username=root --spring.datasource.password=secret

3.3 外部配置文件

Spring Boot支持从外部配置文件加载配置，这些文件可以放置在项目外部的指定位置。

  1. # 使用外部配置文件启动应用
  2. $ java -jar myapp.jar --spring.config.location=/path/to/external/application.properties

4. 多环境配置

在实际开发中，应用通常需要在多个环境中运行，如开发环境、测试环境和生产环境。Spring Boot支持多环境配置，允许开发者为不同环境定义不同的配置文件。

4.1 使用Profile配置

Spring Boot的Profile机制允许开发者为不同的环境定义不同的配置文件。默认的配置文件为application.properties或application.yml，特定环境的配置文件可以命名为application-{profile}.properties或application-{profile}.yml。

  1. # application-dev.properties 示例
  2. server.port=8081
  3. spring.datasource.url=jdbc:mysql://localhost:3306/devdb
  4. spring.datasource.username=devuser
  5. spring.datasource.password=devpass
  7. # application-prod.properties 示例
  8. server.port=8080
  9. spring.datasource.url=jdbc:mysql://localhost:3306/proddb
  10. spring.datasource.username=produser
  11. spring.datasource.password=prodpass

4.2 激活Profile

开发者可以通过多种方式激活特定的Profile，包括命令行参数、环境变量和配置文件等。

  1. # application.properties 示例
  2. spring.profiles.active=dev
  1. # 使用命令行参数激活Profile
  2. $ java -jar myapp.jar --spring.profiles.active=prod

5. 类型安全的配置属性

Spring Boot允许开发者将配置属性映射到Java类中，提供类型安全的配置方式。这种方式提高了配置的可维护性和可读性。

5.1 @ConfigurationProperties注解

@ConfigurationProperties注解用于将配置属性映射到Java类中。开发者可以在配置类中定义属性，并使用@ConfigurationProperties注解指定前缀。

  1. # application.properties 示例
  2. myapp.datasource.url=jdbc:mysql://localhost:3306/mydb
  3. myapp.datasource.username=root
  4. myapp.datasource.password=secret
  1. // DataSourceProperties.java 示例
  2. @ConfigurationProperties(prefix = "myapp.datasource")
  3. public class DataSourceProperties {
  4.     private String url;
  5.     private String username;
  6.     private String password;
  8.     // Getters and setters
  9. }

5.2 @EnableConfigurationProperties注解

@EnableConfigurationProperties注解用于启用类型安全的配置类。可以在配置类或主应用类中使用该注解。

  1. // AppConfig.java 示例
  2. @Configuration
  3. @EnableConfigurationProperties(DataSourceProperties.class)
  4. public class AppConfig {
  5.     @Bean
  6.     public DataSource dataSource(DataSourceProperties properties) {
  7.         HikariConfig config = new HikariConfig();
  8.         config.setJdbcUrl(properties.getUrl());
  9.         config.setUsername(properties.getUsername());
  10.         config.setPassword(properties.getPassword());
  11.         return new HikariDataSource(config);
  12.     }
  13. }

6. 配置文件加密

在实际项目中，配置文件中可能包含敏感信息，如数据库密码、API密钥等。为了保护这些敏感信息，可以对配置文件进行加密。

6.1 使用Jasypt加密配置属性

Jasypt是一个Java库，用于简化配置文件中的加密和解密操作。Spring Boot与Jasypt集成后，可以方便地加密配置属性。

首先，添加Jasypt依赖：

  1. <!-- pom.xml 示例 -->
  2. <dependency>
  3.     <groupId>com.github.ulisesbocchio</groupId>
  4.     <artifactId>jasypt-spring-boot-starter</artifactId>
  5.     <version>3.0.4</version>
  6. </dependency>

然后，在配置文件中使用ENC()函数加密属性值：

  1. # application.properties 示例
  2. spring.datasource.password=ENC(encryptedPassword)

最后，配置Jasypt加密密钥：

  1. # application.properties 示例
  2. jasypt.encryptor.password=mySecretKey

6.2 编写自定义加密器

如果需要自定义加密逻辑，可以编写自定义加密器并注册为Spring Bean。

  1. // CustomEncryptor.java 示例
  2. @Bean(name = "encryptorBean")
  3. public StringEncryptor stringEncryptor() {
  4.     PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
  5.     SimpleStringPBEConfig config = new SimpleStringPBEConfig();
  6.     config.setPassword("mySecretKey");
  7.     config.setAlgorithm("PBEWithMD5AndDES");
  8.     config.setKeyObtentionIterations("1000");
  9.     config.setPoolSize("1");
  10.     config.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
  11.     config.setStringOutputType("base64");
  12.     encryptor.setConfig(config);
  13.     return encryptor;
  14. }

7. 动态配置更新

在一些场景下，应用需要在不重启的情况下动态更新配置。Spring Boot提供了多种方式实现动态配置更新，包括Spring Cloud Config、Consul和Zookeeper等。

7.1 使用Spring Cloud Config

Spring Cloud Config是一个分布式配置管理工具，支持将配置存储在Git、SVN等版本控制系统中，并在应用运行时动态加载配置。

首先，添加Spring Cloud Config依赖：

  1. <!-- pom.xml 示例 -->
  2. <dependency>
  3.     <groupId>org.springframework.cloud</groupId>
  4.     <artifactId>spring-cloud-starter-config</artifactId>
  5. </dependency>

然后，配置Spring Cloud Config服务器：

  1. # application.properties 示例
  2. spring.cloud.config.server.git.uri=https://github.com
  4. /myorg/myconfig-repo
  5. spring.cloud.config.server.git.clone-on-start=true

最后，配置Spring Cloud Config客户端：

  1. # application.properties 示例
  2. spring.cloud.config.uri=http://localhost:8888

7.2 使用Spring Cloud Bus

Spring Cloud Bus用于将配置更新事件广播到所有注册的客户端，实现配置的实时更新。

首先，添加Spring Cloud Bus依赖：

  1. <!-- pom.xml 示例 -->
  2. <dependency>
  3.     <groupId>org.springframework.cloud</groupId>
  4.     <artifactId>spring-cloud-starter-bus-amqp</artifactId>
  5. </dependency>

然后，配置Spring Cloud Bus：

  1. # application.properties 示例
  2. spring.rabbitmq.host=localhost
  3. spring.rabbitmq.port=5672
  4. spring.rabbitmq.username=guest
  5. spring.rabbitmq.password=guest

最后，在配置更新后，通过POST请求触发更新事件：

  1. $ curl -X POST http://localhost:8080/actuator/bus-refresh

8. 实践案例：构建一个复杂的Spring Boot项目

为了更好地理解Spring Boot配置文件的使用，下面我们通过一个实际案例，展示如何在一个复杂项目中使用各种配置技巧。

8.1 项目背景

假设我们要开发一个电商系统，包含用户管理、商品管理和订单处理等多个模块。我们需要在项目中灵活地管理配置，支持多环境配置、动态配置更新和配置文件加密等需求。

8.2 项目结构

  1. ecommerce
  2. ├── src
  3. │   ├── main
  4. │   │   ├── java
  5. │   │   │   └── com
  6. │   │   │       └── example
  7. │   │   │           └── ecommerce
  8. │   │   │               ├── config
  9. │   │   │               │   ├── DataSourceConfig.java
  10. │   │   │               │   ├── SecurityConfig.java
  11. │   │   │               │   ├── AppConfig.java
  12. │   │   │               ├── controller
  13. │   │   │               │   ├── UserController.java
  14. │   │   │               │   ├── ProductController.java
  15. │   │   │               ├── service
  16. │   │   │               │   ├── UserService.java
  17. │   │   │               │   ├── ProductService.java
  18. │   │   ├── resources
  19. │   │   │   ├── application.properties
  20. │   │   │   ├── application-dev.properties
  21. │   │   │   ├── application-prod.properties
  22. │   │   │   ├── bootstrap.properties
  23. └── pom.xml

8.3 配置文件

  1. # application.properties 示例
  2. spring.profiles.active=dev
  4. # application-dev.properties 示例
  5. server.port=8081
  6. spring.datasource.url=jdbc:mysql://localhost:3306/devdb
  7. spring.datasource.username=devuser
  8. spring.datasource.password=devpass
  10. # application-prod.properties 示例
  11. server.port=8080
  12. spring.datasource.url=jdbc:mysql://localhost:3306/proddb
  13. spring.datasource.username=produser
  14. spring.datasource.password=prodpass
  16. # bootstrap.properties 示例
  17. spring.cloud.config.uri=http://localhost:8888

8.4 配置类

  1. // DataSourceConfig.java 示例
  2. @Configuration
  3. public class DataSourceConfig {
  5.     @Bean
  6.     @ConfigurationProperties(prefix = "spring.datasource")
  7.     public DataSource dataSource() {
  8.         return DataSourceBuilder.create().build();
  9.     }
  10. }
  12. // SecurityConfig.java 示例
  13. @Configuration
  14. @EnableWebSecurity
  15. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  16.     @Override
  17.     protected void configure(HttpSecurity http) throws Exception {
  18.         http
  19.             .authorizeRequests()
  20.                 .antMatchers("/public/**").permitAll()
  21.                 .anyRequest().authenticated()
  22.             .and()
  23.             .formLogin().loginPage("/login").permitAll()
  24.             .and()
  25.             .logout().permitAll();
  26.     }
  27. }
  29. // AppConfig.java 示例
  30. @Configuration
  31. @Import({DataSourceConfig.class, SecurityConfig.class})
  32. public class AppConfig {
  33. }

8.5 控制器和服务类

  1. // UserController.java 示例
  2. @RestController
  3. @RequestMapping("/users")
  4. public class UserController {
  6.     @Autowired
  7.     private UserService userService;
  9.     @PostMapping
  10.     public User createUser(@RequestBody User user) {
  11.         return userService.createUser(user);
  12.     }
  14.     @GetMapping("/{id}")
  15.     public User getUserById(@PathVariable Long id) {
  16.         return userService.getUserById(id);
  17.     }
  18. }
  20. // ProductController.java 示例
  21. @RestController
  22. @RequestMapping("/products")
  23. public class ProductController {
  25.     @Autowired
  26.     private ProductService productService;
  28.     @PostMapping
  29.     public Product createProduct(@RequestBody Product product) {
  30.         return productService.createProduct(product);
  31.     }
  33.     @GetMapping("/{id}")
  34.     public Product getProductById(@PathVariable Long id) {
  35.         return productService.getProductById(id);
  36.     }
  37. }
  39. // UserService.java 示例
  40. @Service
  41. public class UserService {
  43.     @Autowired
  44.     private UserRepository userRepository;
  46.     public User createUser(User user) {
  47.         return userRepository.save(user);
  48.     }
  50.     public User getUserById(Long id) {
  51.         return userRepository.findById(id).orElse(null);
  52.     }
  53. }
  55. // ProductService.java 示例
  56. @Service
  57. public class ProductService {
  59.     @Autowired
  60.     private ProductRepository productRepository;
  62.     public Product createProduct(Product product) {
  63.         return productRepository.save(product);
  64.     }
  66.     public Product getProductById(Long id) {
  67.         return productRepository.findById(id).orElse(null);
  68.     }
  69. }

8.6 配置文件加密

使用Jasypt加密数据库密码：

  1. # application-prod.properties 示例
  2. spring.datasource.password=ENC(encryptedPassword)

在项目中配置Jasypt加密密钥：

  1. # bootstrap.properties 示例
  2. jasypt.encryptor.password=mySecretKey

8.7 动态配置更新

使用Spring Cloud Config和Spring Cloud Bus实现动态配置更新：

  1. # bootstrap.properties 示例
  2. spring.cloud.config.uri=http://localhost:8888
  3. spring.rabbitmq.host=localhost
  4. spring.rabbitmq.port=5672
  5. spring.rabbitmq.username=guest
  6. spring.rabbitmq.password=guest

在配置更新后，通过POST请求触发更新事件：

  1. $ curl -X POST http://localhost:8080/actuator/bus-refresh

9. 总结

Spring Boot的配置文件管理提供了丰富的功能，帮助开发者在不同的环境中灵活地管理和调整应用的配置。通过本文的介绍，我们了解了Spring Boot配置文件的各种使用方式，包括配置文件的格式和加载顺序、外部化配置、多环境配置、类型安全的配置属性、配置文件加密和动态配置更新等。此外，通过实际案例，我们进一步理解了如何在复杂项目中应用这些配置技巧。

希望本文能够帮助你更好地掌握Spring Boot配置文件的知识和技能，提高你的开发效率和应用的可维护性。如果你有任何问题或建议，欢迎在评论区留言，我们将及时回复。