MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Spring Boot中的配置文件管理

2022-12-114.6k 阅读

Spring Boot 配置文件概述

在 Spring Boot 应用开发中，配置文件扮演着至关重要的角色。它允许开发者在不修改代码的情况下，灵活地调整应用的各种参数，例如数据库连接信息、服务器端口、日志级别等。Spring Boot 支持多种类型的配置文件格式，其中最常用的是 properties 和 YAML 格式。

properties 格式

properties 格式是一种非常传统的配置文件格式，它以键值对的形式存储数据，每行一个键值对，键和值之间用等号（=）或冒号（:）分隔。例如：

server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password

在 properties 文件中，注释使用井号（#）开头。这种格式简单直观，对于简单的配置场景非常适用。

YAML 格式

YAML（YAML Ain't Markup Language）是一种人类友好的数据序列化标准，以简洁易读著称。在 Spring Boot 中，YAML 格式的配置文件也被广泛使用。YAML 使用缩进表示层级关系，用冒号（:）表示键值对。例如：

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: password

YAML 文件支持使用短横线（-）表示列表。例如，如果要配置多个日志级别：

logging:
  level:
    com.example: debug
    org.springframework: info

YAML 格式相比 properties 格式，在表达复杂层级结构的数据时更加清晰和简洁。

多环境配置

在实际开发中，一个应用通常会有不同的运行环境，如开发环境（development）、测试环境（test）和生产环境（production）。每个环境可能需要不同的配置，例如开发环境可能需要更详细的日志输出，而生产环境则更注重性能和稳定性。Spring Boot 提供了强大的多环境配置支持。

配置文件命名规则

Spring Boot 通过特定的命名规则来识别不同环境的配置文件。对于 properties 格式，不同环境的配置文件命名格式为 application-{profile}.properties，其中 {profile} 就是环境标识，例如 application-dev.properties 表示开发环境配置文件，application-prod.properties 表示生产环境配置文件。

对于 YAML 格式，可以在一个 application.yml 文件中通过 spring.profiles 来区分不同环境的配置。例如：

# application.yml
spring:
  profiles: dev
server:
  port: 8081

---
spring:
  profiles: prod
server:
  port: 8080

在上述 YAML 文件中，通过 --- 分隔不同环境的配置。每个环境配置块中通过 spring.profiles 指定对应的环境。

激活指定环境

可以通过多种方式激活指定的环境配置。

通过命令行参数：在启动 Spring Boot 应用时，可以通过 --spring.profiles.active 参数指定激活的环境。例如：

java -jar myapp.jar --spring.profiles.active=prod

通过系统属性：在系统属性中设置 spring.profiles.active。例如，在 Linux 系统中，可以通过以下命令设置：

export SPRING_PROFILES_ACTIVE=dev
java -jar myapp.jar

在配置文件中设置：也可以在 application.properties 或 application.yml 文件中设置 spring.profiles.active。例如，在 application.properties 中：

spring.profiles.active=test

在 application.yml 中：

spring:
  profiles:
    active: test

配置文件加载顺序

Spring Boot 启动时会按照一定的顺序加载配置文件，了解这个顺序对于正确配置应用非常重要。

  1. 命令行参数：通过命令行传递的参数优先级最高，例如 --server.port=8082 会覆盖其他配置文件中的 server.port 设置。
  2. 来自 SPRING_APPLICATION_JSON 的属性：可以通过 SPRING_APPLICATION_JSON 环境变量设置 JSON 格式的配置属性，这些属性也具有较高优先级。
  3. Java 系统属性（System.getProperties()）：Java 系统属性可以在应用启动时设置，例如 -Dspring.datasource.password=secret。
  4. 操作系统环境变量：操作系统的环境变量也会被 Spring Boot 应用读取，例如 SPRING_DATASOURCE_PASSWORD=secret。
  5. RandomValuePropertySource：用于生成随机数，如 random.int、random.long 等。
  6. 应用配置文件：按照 application-{profile}.properties 或 application.yml 及其不同环境变体的顺序加载。其中，application.properties 或 application.yml 基础配置文件优先级最低，特定环境的配置文件优先级较高。

例如，如果在 application.properties 中有 server.port=8080，在 application-dev.properties 中有 server.port=8081，且激活的是开发环境，那么最终生效的 server.port 是 8081。

自定义配置属性

除了 Spring Boot 内置的配置属性外，开发者通常还需要定义自己的配置属性。

定义配置类

首先，创建一个 Java 类来封装自定义配置属性。例如，假设我们有一个应用需要配置一些与邮件服务相关的属性：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "mail")
public class MailProperties {
    private String host;
    private int port;
    private String username;
    private String password;

    // 省略 getters 和 setters
    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

在上述代码中，使用 @ConfigurationProperties(prefix = "mail") 注解指定配置属性的前缀为 mail。这意味着在配置文件中，相关属性的键应该以 mail 开头。

在配置文件中设置属性

在 application.properties 或 application.yml 文件中设置自定义属性。例如，在 application.properties 中：

mail.host=smtp.example.com
mail.port=587
mail.username=your-email@example.com
mail.password=your-password

在 application.yml 中：

mail:
  host: smtp.example.com
  port: 587
  username: your-email@example.com
  password: your-password

使用自定义配置属性

在需要使用这些属性的地方，通过依赖注入获取配置类的实例。例如，在一个邮件发送服务类中：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MailService {
    private final MailProperties mailProperties;

    @Autowired
    public MailService(MailProperties mailProperties) {
        this.mailProperties = mailProperties;
    }

    public void sendMail() {
        String host = mailProperties.getHost();
        int port = mailProperties.getPort();
        String username = mailProperties.getUsername();
        String password = mailProperties.getPassword();
        // 这里编写邮件发送逻辑，使用获取到的配置属性
    }
}

通过这种方式，我们可以方便地管理和使用自定义的配置属性。

配置文件加密

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

使用 Jasypt 加密

Jasypt 是一个 Java 库，用于在 Java 应用中轻松地加密和解密数据。

添加依赖：在 pom.xml 文件中添加 Jasypt 依赖：

<dependency>
    <groupId>com.github.ulisesbocchio</groupId>
    <artifactId>jasypt-spring-boot-starter</artifactId>
    <version>3.0.3</version>
</dependency>

配置加密密钥：在 application.properties 或 application.yml 文件中配置加密密钥。例如，在 application.properties 中：

jasypt.encryptor.password=mysecretkey

加密敏感信息：使用 Jasypt 提供的命令行工具或 API 对敏感信息进行加密。例如，使用命令行工具加密数据库密码：

java -cp jasypt-1.9.3.jar org.jasypt.intf.cli.JasyptPBEStringEncryptionCLI input="password" password=mysecretkey algorithm=PBEWithMD5AndDES

上述命令会输出加密后的字符串。

在配置文件中使用加密值：在配置文件中使用加密后的字符串，例如在 application.properties 中：

spring.datasource.password=ENC(Rm9vYmFyMTIz)

这里 ENC(...) 表示这是一个加密值。

解密配置：Spring Boot 启动时，Jasypt 会自动使用配置的密钥对加密值进行解密，应用程序可以正常使用解密后的真实值。

动态配置更新

在一些场景下，希望在应用运行时动态更新配置，而不需要重启应用。Spring Boot 提供了一些机制来支持动态配置更新。

使用 Spring Cloud Config

Spring Cloud Config 是一个分布式配置管理工具，它可以集中管理应用的配置，并支持动态更新。

搭建配置服务器：首先需要搭建一个 Spring Cloud Config 服务器。添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

配置服务器的配置文件 application.yml 示例：

server:
  port: 8888
spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/your-repo/config-repo

上述配置表示从指定的 Git 仓库读取配置文件。

客户端配置：在客户端应用中添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

在 bootstrap.properties 或 bootstrap.yml 文件中配置客户端连接到配置服务器：

spring:
  application:
    name: myapp
  cloud:
    config:
      uri: http://localhost:8888
      fail-fast: true

动态刷新配置：通过 @RefreshScope 注解和 /actuator/refresh 端点实现动态配置更新。在需要动态更新配置的类上添加 @RefreshScope 注解：

import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Component;

@RefreshScope
@Component
public class MyConfigComponent {
    // 这里可以注入配置属性，并且在配置更新时自动刷新
}

然后，通过发送 POST 请求到 /actuator/refresh 端点来触发配置更新。例如：

curl -X POST http://localhost:8080/actuator/refresh

这样，应用就可以在不重启的情况下更新配置。

配置文件与容器化

随着容器化技术的广泛应用，如 Docker 和 Kubernetes，配置文件管理在容器环境中也有一些特殊的考虑。

在 Docker 中使用配置文件

在构建 Docker 镜像时，可以将配置文件复制到镜像中。例如，在 Dockerfile 中：

FROM openjdk:11
COPY target/myapp.jar /app/
COPY application.properties /app/
WORKDIR /app
CMD ["java", "-jar", "myapp.jar"]

上述 Dockerfile 将 application.properties 文件复制到容器的 /app 目录中，并在启动容器时使用该配置文件运行应用。

另外，也可以通过环境变量传递配置信息。例如，在 Docker 启动命令中：

docker run -e SPRING_DATASOURCE_PASSWORD=secret -p 8080:8080 myapp:latest

在应用中，可以通过 @Value("${spring.datasource.password}") 来获取该环境变量的值。

在 Kubernetes 中使用配置文件

在 Kubernetes 中，可以使用 ConfigMap 来管理配置文件。首先，创建一个 ConfigMap：

apiVersion: v1
kind: ConfigMap
metadata:
  name: myapp-config
data:
  application.properties: |
    server.port=8080
    spring.datasource.url=jdbc:mysql://mysql-service:3306/mydb
    spring.datasource.username=root
    spring.datasource.password=secret

然后，在 Deployment 中挂载 ConfigMap：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        volumeMounts:
        - name: config-volume
          mountPath: /app/config
          subPath: application.properties
      volumes:
      - name: config-volume
        configMap:
          name: myapp-config

这样，容器中的应用就可以从挂载的配置文件中读取配置信息。

通过以上对 Spring Boot 中配置文件管理的深入探讨，我们可以看到 Spring Boot 提供了丰富且灵活的配置管理功能，无论是在不同环境的配置切换、自定义配置属性的管理，还是配置文件的加密和动态更新等方面，都能满足各种复杂的应用需求。在实际开发中，合理运用这些配置管理技术，可以提高应用的可维护性、灵活性和安全性。同时，结合容器化技术，能够更好地适应现代分布式应用的部署和运维需求。