上周，团队里的小王在部署一个紧急修复版本时，由于匆忙，忘记将配置文件中的 Redis 连接地址从 localhost 改为生产环境的域名。结果，新版本上线后，所有缓存相关功能全部失效，导致用户购物车数据丢失，引发了一次 P3 级线上事故。

根本原因：项目中没有清晰、强制性的多环境配置隔离机制，依赖人工记忆和操作，极易出错。

在现代化的软件开发流程中，我们的应用通常需要在多个环境中运行：

  • 开发环境 (dev)：开发者本地机器，连接本地数据库和服务
  • 测试环境 (test)：QA团队进行测试，使用独立的测试数据库
  • 预发布环境 (staging)：模拟生产环境，用于最终验证
  • 生产环境 (prod)：最终用户使用的线上环境

Spring Boot 的多环境配置（Profile）功能，正是为解决这一问题而生的核心特性。它让我们能够为不同环境定义不同的配置，并在打包、启动时轻松切换。

本文将基于 Spring Boot 3.2.x 和 JDK 17，一起探究 SpringBoot 中的多环境配置。

一、Spring Boot 多环境配置核心机制

1. 配置文件命名规则

Spring Boot 约定大于配置。多环境的核心在于配置文件的命名格式：

application-{profile}.yml

或

application-{profile}.properties

其中 {profile} 就是你定义的环境标识，如 dev, test, prod。

优先级与覆盖规则：

  1. application.yml (主配置，所有环境共享)
  2. application-{profile}.yml (特定环境配置，覆盖主配置中的相同项)
  3. 命令行参数 (优先级最高，如 --server.port=8081)
  4. 系统环境变量

2. 激活指定环境的方式

有多种方式可以激活某个环境配置，按优先级从高到低：

激活方式 示例 适用场景
命令行参数 java -jar app.jar --spring.profiles.active=prod 生产部署、容器化（Docker）
系统环境变量 export SPRING_PROFILES_ACTIVE=prod 服务器全局设置、CI/CD
JVM系统属性 -Dspring.profiles.active=dev 本地IDE运行
配置文件指定 在application.yml中写spring.profiles.active: dev 不推荐用于生产，易被提交

企业级最佳实践：在测试和生产环境中，强制使用命令行参数或系统环境变量来激活Profile，避免将敏感的环境信息硬编码在配置文件中提交到代码库。

二、企业级多环境配置实战

我们将构建一个简单的用户服务，展示在 dev 和 prod 环境下，如何配置不同的数据源、Redis、日志级别以及第三方API地址。

1. 项目结构与依赖

首先，确保你的 pom.xml 包含必要依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.5</version> <!-- 使用Spring Boot 3.2.x -->
    </parent>

    <groupId>com.example</groupId>
    <artifactId>multi-profile-demo</artifactId>
    <version>1.0.0</version>

    <properties>
        <java.version>17</java.version> <!-- 使用JDK 17 -->
        <mybatis-plus.version>3.5.6</mybatis-plus.version>
        <springdoc.version>2.5.0</springdoc.version>
    </properties>

    <dependencies>
        <!-- Web核心 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 数据库 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- MyBatis-Plus (需指定版本，因Boot父POM未管理) -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>
        <!-- Redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- 参数校验 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <!-- 文档 (SpringDoc OpenAPI 3.0) -->
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
            <version>${springdoc.version}</version>
        </dependency>
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2. 多层次配置文件详解

我们将配置文件放在 src/main/resources 下，结构如下：

resources/
├── application.yml          # 主配置，所有环境共享
├── application-dev.yml      # 开发环境配置
├── application-test.yml     # 测试环境配置
└── application-prod.yml     # 生产环境配置

（1）主配置文件 application.yml

这里放置所有环境的通用配置和默认值。通过 spring.config.import 引入其他配置（Spring Boot 2.4+ 推荐方式）。

# application.yml
spring:
  application:
    name: multi-profile-demo
  # 2.4+ 新语法：显式导入其他配置文件，更清晰
  config:
    import:
      - application-common.yml
      - classpath:application-${spring.profiles.active}.yml
  # 默认激活 dev 环境，方便本地开发
  # 【注意】生产部署时务必通过命令行参数覆盖此值！
  profiles:
    active: dev

# 所有环境共享的配置
server:
  servlet:
    encoding:
      charset: UTF-8
      force: true

# MyBatis-Plus 通用配置
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 控制台打印SQL，按需开启
    map-underscore-to-camel-case: true
  global-config:
    db-config:
      logic-delete-field: deleted  # 全局逻辑删除字段名
      logic-delete-value: 1        # 逻辑已删除值
      logic-not-delete-value: 0    # 逻辑未删除值

# SpringDoc OpenAPI 配置
springdoc:
  api-docs:
    path: /v3/api-docs
  swagger-ui:
    path: /swagger-ui.html
    tags-sorter: alpha
    operations-sorter: alpha

（2）开发环境配置 application-dev.yml

开发环境追求便捷和可调试性。

# application-dev.yml
server:
  port: 8080

# 开发环境数据源 (本地MySQL)
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test_db?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false
    username: root
    password: 123456
    hikari:
      maximum-pool-size: 10
      minimum-idle: 5
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000

  # 开发环境 Redis (本地)
  data:
      redis:
        host: localhost
        port: 6379
        password: '' # 本地无密码
        database: 0
        lettuce:
          pool:
            max-active: 20
            max-idle: 10
            min-idle: 5

# 开发环境日志级别：更详细
logging:
  level:
    root: INFO
    com.example.demo: DEBUG  # 项目包路径设为DEBUG
    org.springframework.jdbc.core.JdbcTemplate: DEBUG # 查看SQL
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %highlight(%-5level) %cyan(%logger{50}) - %msg%n"
  file:
    name: logs/app-dev.log

# 开发环境专属配置
demo:
  config:
    env-name: "开发环境"
    api-base-url: "http://localhost:18080"
    feature-toggle:
      enable-cache: false  # 开发时关闭缓存方便调试
      enable-job: false    # 开发时关闭定时任务

（3）生产环境配置 application-prod.yml

生产环境核心是性能、稳定性和安全。

# application-prod.yml
server:
  port: 80
  # 生产环境通常有反向代理 (如Nginx)，需要配置真实IP和上下文
  forward-headers-strategy: framework
  tomcat:
    max-connections: 10000
    max-threads: 200
    min-spare-threads: 20

# 生产环境数据源 (RDS/云数据库)
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://rm-xxx.mysql.rds.aliyuncs.com:3306/prod_db?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=true&requireSSL=true
    username: ${DB_USERNAME:prod_user} # 从环境变量读取，安全性！
    password: ${DB_PASSWORD:}           # 密码绝不能硬编码！
    hikari:
      maximum-pool-size: 20             # 生产环境连接池可调大
      minimum-idle: 10
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
      connection-test-query: SELECT 1  # MySQL连接健康检查

  # 生产环境 Redis (集群/哨兵)
  data:
    redis:
      host: ${REDIS_HOST:r-xxx.redis.rds.aliyuncs.com}
      port: ${REDIS_PORT:6379}
      password: ${REDIS_PASSWORD:}      # 从环境变量读取
      database: 0
      timeout: 2000ms
      lettuce:
        cluster:
          nodes: # 集群配置示例
            - r-xxx.redis.rds.aliyuncs.com:6379
            - r-yyy.redis.rds.aliyuncs.com:6379
        pool:
          max-active: 50
          max-idle: 20
          min-idle: 10
          max-wait: 1000ms

# 生产环境日志级别：INFO及以上，减少I/O
logging:
  level:
    root: WARN
    com.example.demo: INFO
    org.springframework: WARN
    com.baomidou.mybatisplus: WARN
  # 结构化日志，便于接入ELK
  pattern:
    # JSON格式，便于日志系统解析
    # console: '{"timestamp":"%d{yyyy-MM-dd HH:mm:ss.SSS}", "level":"%level", "thread":"%thread", "logger":"%logger{40}", "message":"%msg", "traceId":"%X{traceId}"}%n'
    # 或保留可读格式
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{40} - [traceId:%X{traceId}] %msg%n"
  file:
    name: /var/log/spring-boot-app/app.log
    max-size: 100MB
    max-history: 30
    total-size-cap: 3GB

# 生产环境专属配置
demo:
  config:
    env-name: "生产环境"
    api-base-url: "https://api.prod.com"
    feature-toggle:
      enable-cache: true
      enable-job: true
    # 生产环境敏感配置，务必使用环境变量
    secret-key: ${APP_SECRET_KEY:}
    payment:
      callback-url: "https://www.prod.com/payment/callback"

3. 在代码中读取环境特定配置

我们可以通过 @Value 或 @ConfigurationProperties 注解，轻松读取不同环境下的配置值。

（1）创建配置属性类

// ConfigProperties.java
package com.example.demo.config;

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

/**
 * 映射 demo.config 下的配置
 * 使用 @ConfigurationProperties 进行类型安全的绑定
 */
@Component
@ConfigurationProperties(prefix = "demo.config")
@Data
public class ConfigProperties {
    /**
     * 环境名称，如：开发环境、生产环境
     */
    private String envName;

    /**
     * API基础地址
     */
    private String apiBaseUrl;

    /**
     * 特性开关
     */
    private FeatureToggle featureToggle = new FeatureToggle();

    @Data
    public static class FeatureToggle {
        /**
         * 是否启用缓存
         */
        private boolean enableCache;

        /**
         * 是否启用定时任务
         */
        private boolean enableJob;
    }
}

（2）创建一个控制器来验证配置读取

// EnvController.java
package com.example.demo.controller;

import com.example.demo.config.ConfigProperties;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@Tag(name = "环境配置", description = "多环境配置验证接口")
@RestController
@RequestMapping("/api/env")
@RequiredArgsConstructor
@Slf4j
public class EnvController {

    private final Environment environment;
    private final ConfigProperties configProperties;

    // 使用 @Value 读取单个属性
    @Value("${server.port}")
    private String serverPort;

    @Value("${spring.datasource.url:#{'Not Set'}}")
    private String datasourceUrl;

    @Operation(summary = "获取当前环境信息")
    @GetMapping("/info")
    public Map<String, Object> getEnvInfo() {
        Map<String, Object> info = new HashMap<>();

        // 1. 当前激活的Profiles
        String[] activeProfiles = environment.getActiveProfiles();
        info.put("activeProfiles", activeProfiles);

        // 2. 从Environment读取
        info.put("serverPort", environment.getProperty("server.port"));
        info.put("appName", environment.getProperty("spring.application.name"));

        // 3. 从@Value注入读取
        info.put("datasourceUrl", maskSensitiveInfo(datasourceUrl)); // 敏感信息脱敏
        info.put("injectedServerPort", serverPort);

        // 4. 从类型安全的配置类读取
        info.put("envNameFromProps", configProperties.getEnvName());
        info.put("apiBaseUrl", configProperties.getApiBaseUrl());
        info.put("featureToggle", configProperties.getFeatureToggle());

        // 5. 判断当前环境
        boolean isDev = environment.acceptsProfiles(org.springframework.core.env.Profiles.of("dev"));
        boolean isProd = environment.acceptsProfiles(org.springframework.core.env.Profiles.of("prod"));
        info.put("isDevEnv", isDev);
        info.put("isProdEnv", isProd);

        log.info("环境信息查询: {}", info);
        return info;
    }

    /**
     * 简单脱敏，隐藏数据库密码
     */
    private String maskSensitiveInfo(String url) {
        if (url == null || !url.contains("@")) {
            return url;
        }
        try {
            // 简单示例：将 jdbc:mysql://user:password@host:port/db
            // 脱敏为 jdbc:mysql://***:***@host:port/db
            int atIndex = url.indexOf('@');
            int start = url.indexOf("://") + 3;
            if (start < atIndex) {
                return url.substring(0, start) + "***:***" + url.substring(atIndex);
            }
        } catch (Exception e) {
            log.warn("脱敏处理失败", e);
        }
        return "***";
    }
}

4. 运行与验证

步骤1：启动应用（激活dev环境）

在 IDEA 中，可以直接在 application.yml 里设置 spring.profiles.active: dev 后启动。

或者通过命令行（在项目根目录）：

# 先打包
mvn clean package -DskipTests

# 以开发环境启动
java -jar target/multi-profile-demo-1.0.0.jar --spring.profiles.active=dev

启动日志中你会看到：

...
2024-05-19 10:00:00.000  INFO 12345 --- [main] c.e.demo.MultiProfileDemoApplication     : The following 1 profile is active: "dev"
...

步骤2：访问验证接口

打开浏览器或使用 curl 访问：

GET http://localhost:8080/api/env/info

预期响应结果 (dev环境)：

{
  "activeProfiles": ["dev"],
  "serverPort": "8080",
  "appName": "multi-profile-demo",
  "datasourceUrl": "jdbc:mysql://***:***@localhost:3306/test_db?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false",
  "injectedServerPort": "8080",
  "envNameFromProps": "开发环境",
  "apiBaseUrl": "http://localhost:18080",
  "featureToggle": {
    "enableCache": false,
    "enableJob": false
  },
  "isDevEnv": true,
  "isProdEnv": false
}

步骤3：切换为生产环境启动

# 通过命令行参数激活prod环境
java -jar target/multi-profile-demo-1.0.0.jar --spring.profiles.active=prod

# 更常见的生产用法：同时设置JVM参数和环境变量
# java -Xms512m -Xmx1024m -Dspring.profiles.active=prod -jar your-app.jar

预期响应结果 (prod环境)：

{
  "activeProfiles": ["prod"],
  "serverPort": "80",
  "appName": "multi-profile-demo",
  "datasourceUrl": "jdbc:mysql://***:***@rm-xxx.mysql.rds.aliyuncs.com:3306/prod_db?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=true&requireSSL=true",
  "injectedServerPort": "80",
  "envNameFromProps": "生产环境",
  "apiBaseUrl": "https://api.prod.com",
  "featureToggle": {
    "enableCache": true,
    "enableJob": true
  },
  "isDevEnv": false,
  "isProdEnv": true
}

可以看到，数据库连接、Redis地址、端口、日志级别、功能开关等配置都根据环境自动切换了。

三、高级特性与最佳实践

1. Profile-specific 配置文件与代码

除了 application-{profile}.yml，Spring Boot 还支持：

  • Profile-specific 的 Java 配置类：使用 @Profile("dev") 注解
@Configuration
@Profile("dev") // 仅在dev环境生效
public class DevConfig {
    @Bean
    public SomeService devSomeService() {
        return new DevSomeServiceImpl();
    }
}

@Configuration
@Profile("prod") // 仅在prod环境生效
public class ProdConfig {
    @Bean
    public SomeService prodSomeService() {
        return new ProdSomeServiceImpl();
    }
}
  • Profile-specific 的配置属性：在 @ConfigurationProperties 类上使用 @Profile

2. 多环境打包策略

Maven Profile 与 Spring Profile 结合

在 pom.xml 中定义 Maven Profile，实现不同环境打包不同配置：

<profiles>
    <profile>
        <id>dev</id>
        <properties>
            <activatedProperties>dev</activatedProperties>
        </properties>
        <activation>
            <activeByDefault>true</activeByDefault> <!-- 默认激活dev -->
        </activation>
    </profile>
    <profile>
        <id>test</id>
        <properties>
            <activatedProperties>test</activatedProperties>
        </properties>
    </profile>
    <profile>
        <id>prod</id>
        <properties>
            <activatedProperties>prod</activatedProperties>
        </properties>
    </profile>
</profiles>

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering> <!-- 开启过滤，替换占位符 -->
            <excludes>
                <exclude>application-*.yml</exclude> <!-- 排除所有环境配置 -->
            </excludes>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
            <includes>
                <!-- 根据Maven Profile动态引入对应配置文件 -->
                <include>application-${activatedProperties}.yml</include>
                <include>application.yml</include>
            </includes>
        </resource>
    </resources>
</build>

然后通过 Maven 命令打包：

# 打开发包
mvn clean package -Pdev

# 打生产包
mvn clean package -Pprod

但更推荐的做法是：使用 单一JAR包 + 外部配置 的方式。即打一个包含所有配置的Fat Jar，在运行时通过 --spring.profiles.active 或 SPRING_PROFILES_ACTIVE 环境变量来激活特定环境。这样更符合云原生和十二因子应用的原则。

3. 敏感信息处理（关键！）

绝对不要 将密码、密钥、AccessToken 等敏感信息硬编码在配置文件中，尤其是提交到代码仓库。

推荐方案：

  1. 环境变量（最简单、最通用）

    # application-prod.yml
spring:
  datasource:
    password: ${DB_PASSWORD} # 从系统环境变量读取

    启动时设置：export DB_PASSWORD=your_password && java -jar app.jar

  2. 配置中心（企业级方案）

    • Spring Cloud Config
    • Apollo
    • Nacos
    • Consul

  3. 云服务商密钥管理

    • AWS Secrets Manager / Parameter Store
    • Azure Key Vault
    • 阿里云 KMS

  4. 加密配置（配合Jasypt等库）

    spring:
  datasource:
    password: ENC(加密后的字符串)

4. 使用 @Conditional 进行条件装配

Spring Boot 提供了丰富的 @Conditional 注解，可以根据环境、属性等条件动态创建Bean。

@Configuration
public class CacheConfig {
    
    // 只有当配置 demo.config.feature-toggle.enable-cache=true 时才启用Redis缓存
    @Bean
    @ConditionalOnProperty(name = "demo.config.feature-toggle.enable-cache", havingValue = "true")
    public CacheManager redisCacheManager(RedisConnectionFactory factory) {
        // 配置Redis缓存管理器
        return RedisCacheManager.create(factory);
    }
    
    // 如果没有启用Redis缓存，则使用简单的内存缓存
    @Bean
    @ConditionalOnMissingBean(CacheManager.class)
    public CacheManager simpleCacheManager() {
        return new ConcurrentMapCacheManager();
    }
}

四、常见陷阱与避坑指南

❌ 错误1：Profile激活失败

问题：设置了 spring.profiles.active=prod 但似乎没生效。
排查：

  1. 检查配置文件命名是否正确：必须是 application-prod.yml 而不是 application-prod.yaml 或 application-prod.properties。
  2. 检查配置位置：必须在 src/main/resources 或类路径下。
  3. 查看启动日志：搜索 The following X profile is active 确认激活的Profiles。

❌ 错误2：配置属性无法读取

问题：@Value("${some.key}") 抛出 IllegalArgumentException: Could not resolve placeholder。
解决：

  1. 确保属性在激活的Profile配置文件中存在。
  2. 使用 environment.getProperty("some.key", "defaultValue") 提供默认值。
  3. 在 @ConfigurationProperties 类上使用 @ConfigurationProperties(prefix="some", ignoreInvalidFields=true, ignoreUnknownFields=true) 来容忍部分属性缺失。

❌ 错误3：配置文件被意外提交

问题：包含密码的 application-prod.yml 被提交到了Git仓库。
预防：

  1. 在 .gitignore 中添加： 
    # 忽略包含敏感信息的生产配置
application-prod.yml
application-prod.properties
  2. 使用 配置模板：提交 application-prod.yml.template 到仓库，其中值用占位符表示，在部署时通过脚本替换。

❌ 错误4：Profile特定Bean冲突

问题：多个Profile定义了同名Bean导致启动失败。
解决：确保同一时间只有一个Profile被激活，或者使用 @Primary 注解指定主Bean。

五、云原生与容器化部署

在 Docker 和 Kubernetes 时代，多环境配置有更优雅的实践：

Dockerfile 示例：

FROM eclipse-temurin:17-jre-alpine
VOLUME /tmp
COPY target/*.jar app.jar
ENTRYPOINT ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/app.jar"]

通过环境变量激活Profile：

# 运行容器时指定
docker run -e "SPRING_PROFILES_ACTIVE=prod" -p 8080:8080 your-app:latest

# 或者使用Docker Compose
# docker-compose.yml
version: '3.8'
services:
  app:
    image: your-app:latest
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - DB_PASSWORD=${DB_PASSWORD}  # 从宿主机环境变量传递
    ports:
      - "8080:8080"

Kubernetes ConfigMap 与 Secret：

# configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  application-prod.yml: |
    spring:
      datasource:
        url: jdbc:mysql://mysql-service:3306/prod_db
    demo:
      config:
        env-name: "K8s生产环境"
---
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      containers:
      - name: app
        image: your-app:latest
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "prod"
        volumeMounts:
        - name: config-volume
          mountPath: /config
      volumes:
      - name: config-volume
        configMap:
          name: app-config

动手尝试：在你的Spring Boot项目中实践多环境配置，并尝试：

  1. 为开发、测试、生产环境分别创建配置
  2. 通过命令行参数切换不同环境
  3. 将数据库密码等敏感信息移出配置文件，改用环境变量传递
  4. 创建一个配置类，读取不同环境下的特定属性并在接口中返回验证

小思考：如果你的应用需要同时激活多个Profile（如 dev,debug），该如何配置？Spring Boot会如何处理多个配置文件的优先级？

欢迎在评论区分享你的实践心得和好的建议哦~

# spring boot # 后端 # java
Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

一个 API 入口调用多个大模型：AiiOnly客户端 + CC Switch 打通 Codex AI编程流程

avatar AI编程社区
cover

VSCode Claude Code + MiMo 中转免登录完整配置教程（解决原生登录弹窗 + 模型报错）

avatar AI编程社区
cover

从零开始做一个属于自己的 Skill（保姆级教程）

avatar AI编程社区