配置绑定与环境隔离

@Service
public class StorageService {
    @Value("${app.storage.endpoint}")
    private String endpoint;
    
    @Value("${app.storage.bucket}")
    private String bucket;
    
    @Value("${app.storage.timeout-seconds:5}")
    private int timeoutSeconds;
}

@Service
public class FileService {
    @Value("${app.storage.endpoint}")  // 重复引用
    private String storageEndpoint;
    
    @Value("${app.storage.bucket}")   // 重复引用
    private String storageBucket;
}

@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    /**
     * 存储服务端点
     */
    private String endpoint;
    
    /**
     * 存储桶名称
     */
    private String bucket;
    
    /**
     * 超时时间(秒)
     */
    private int timeoutSeconds = 5;  // 默认值
    
    /**
     * 是否启用 HTTPS
     */
    private boolean enableHttps = true;
    
    // Getters and Setters
}

app:
  storage:
    endpoint: https://oss.example.com
    bucket: java-note
    timeout-seconds: 10
    enable-https: true

// × @Value 方式：散落、难追踪、类型不安全
@Value("${app.storage.timeout-seconds:5}")
private String timeoutStr;  // 需要手动转换
int timeout = Integer.parseInt(timeoutStr);

// √ @ConfigurationProperties 方式：集中、类型安全、IDE友好
@Autowired
private StorageProperties storageProperties;

int timeout = storageProperties.getTimeoutSeconds();  // 类型安全

@Component
@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    private String endpoint;
    private String bucket;
    private int timeoutSeconds = 5;
    
    // Getters and Setters
    public String getEndpoint() {
        return endpoint;
    }
    
    public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;
    }
    
    public String getBucket() {
        return bucket;
    }
    
    public void setBucket(String bucket) {
        this.bucket = bucket;
    }
    
    public int getTimeoutSeconds() {
        return timeoutSeconds;
    }
    
    public void setTimeoutSeconds(int timeoutSeconds) {
        this.timeoutSeconds = timeoutSeconds;
    }
}

@Service
public class StorageService {
    
    @Autowired
    private StorageProperties storageProperties;
    
    public void upload(String key, byte[] data) {
        String endpoint = storageProperties.getEndpoint();
        String bucket = storageProperties.getBucket();
        int timeout = storageProperties.getTimeoutSeconds();
        
        // 使用配置
    }
}

@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    private String endpoint;
    private String bucket;
    private int timeoutSeconds = 5;
    
    // Getters and Setters
}

@Configuration
@EnableConfigurationProperties(StorageProperties.class)
public class StorageConfiguration {
    
    @Bean
    public StorageService storageService(StorageProperties properties) {
        return new StorageService(properties);
    }
}

@Configuration
public class StorageConfiguration {
    
    @Bean
    @ConfigurationProperties(prefix = "app.storage")
    public StorageProperties storageProperties() {
        return new StorageProperties();
    }
    
    @Bean
    public StorageService storageService(StorageProperties properties) {
        return new StorageService(properties);
    }
}

@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    private int timeoutSeconds;  // Java 属性名
    
    // Getter and Setter
}

# 1. 短横线格式(推荐)
app:
  storage:
    timeout-seconds: 10

# 2. 下划线格式(环境变量常用)
APP_STORAGE_TIMEOUT_SECONDS=10

# 3. 驼峰格式
app:
  storage:
    timeoutSeconds: 10

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

@ConfigurationProperties(prefix = "app.storage")
@Validated
public class StorageProperties {
    
    /**
     * 存储服务端点
     */
    @NotBlank(message = "存储端点不能为空")
    @Pattern(regexp = "^https?://.*", message = "端点必须是有效的URL")
    private String endpoint;
    
    /**
     * 存储桶名称
     */
    @NotBlank(message = "存储桶名称不能为空")
    @Pattern(regexp = "^[a-z0-9-]{3,63}$", 
             message = "存储桶名称必须是3-63个小写字母、数字或短横线")
    private String bucket;
    
    /**
     * 超时时间(秒)
     */
    @Min(value = 1, message = "超时时间至少1秒")
    @Max(value = 60, message = "超时时间最多60秒")
    private int timeoutSeconds = 5;
    
    /**
     * 最大文件大小(MB)
     */
    @Min(value = 1, message = "最小文件大小1MB")
    @Max(value = 100, message = "最大文件大小100MB")
    private int maxFileSizeMb = 10;
    
    /**
     * 重试次数
     */
    @Min(0)
    @Max(5)
    private int retryTimes = 3;
    
    /**
     * 启用的环境列表
     */
    @NotEmpty(message = "至少需要配置一个环境")
    private List<String> enabledEnvironments = new ArrayList<>();
    
    // Getters and Setters
}

@SpringBootApplication
@EnableConfigurationProperties(StorageProperties.class)
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Binding to target StorageProperties failed:

    Field 'endpoint' must match the regex '^https?://.*'
    Field 'bucket' must match '^[a-z0-9-]{3,63}$'
    Field 'timeoutSeconds' must be at least 1

@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {
    
    @NotNull
    @Valid  // 启用嵌套校验
    private Storage storage;
    
    @NotNull
    @Valid
    private Database database;
    
    // Getters and Setters
    
    public static class Storage {
        
        @NotBlank
        private String endpoint;
        
        @NotBlank
        private String bucket;
        
        // Getters and Setters
    }
    
    public static class Database {
        
        @NotBlank
        private String url;
        
        @NotBlank
        private String username;
        
        // Getters and Setters
    }
}

@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    private String endpoint;  // 默认 null
    private String bucket;    // 默认 null
    private int timeoutSeconds = 5;  // 默认 5
    private boolean enableHttps = true;  // 默认 true
    private int retryTimes = 3;  // 默认 3
    
    // Getters and Setters
}

@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    /**
     * 可选的代理地址
     */
    private String proxyHost;
    
    /**
     * 可选的代理端口
     */
    private Integer proxyPort;
    
    public Optional<String> getProxyHost() {
        return Optional.ofNullable(proxyHost);
    }
    
    public Optional<Integer> getProxyPort() {
        return Optional.ofNullable(proxyPort);
    }
}

@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    /**
     * 允许的文件类型
     */
    private List<String> allowedTypes = Arrays.asList("jpg", "png", "gif");
    
    /**
     * 区域配置
     */
    private Map<String, String> regions = new HashMap<>();
    
    // Getters and Setters
}

app:
  storage:
    allowed-types:
      - jpg
      - png
      - gif
      - pdf  # 追加到默认列表
    regions:
      cn-east: shanghai
      cn-north: beijing

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    
    private List<String> servers = new ArrayList<>();
    
    private String[] allowedOrigins;
    
    // Getters and Setters
}

app:
  servers:
    - server1.example.com
    - server2.example.com
    - server3.example.com
  allowed-origins:
    - https://example.com
    - https://api.example.com

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    
    private Map<String, String> endpoints = new HashMap<>();
    
    private Map<String, Integer> timeouts = new HashMap<>();
    
    // Getters and Setters
}

app:
  endpoints:
    auth: https://auth.example.com
    api: https://api.example.com
    cdn: https://cdn.example.com
  timeouts:
    connect: 5000
    read: 10000
    write: 15000

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    
    private Storage storage = new Storage();
    private Database database = new Database();
    
    // Getters and Setters
    
    public static class Storage {
        
        private String endpoint;
        private String bucket;
        private int timeoutSeconds = 5;
        
        // Getters and Setters
    }
    
    public static class Database {
        
        private String url;
        private String username;
        private String password;
        private int maxPoolSize = 10;
        
        // Getters and Setters
    }
}

app:
  storage:
    endpoint: https://oss.example.com
    bucket: my-bucket
    timeout-seconds: 10
  database:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret
    max-pool-size: 20

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    
    /**
     * 会话超时时间
     */
    private Duration sessionTimeout = Duration.ofMinutes(30);
    
    /**
     * 缓存过期时间
     */
    private Duration cacheExpire = Duration.ofHours(24);
    
    /**
     * 数据保留周期
     */
    private Period dataRetention = Period.ofDays(30);
    
    // Getters and Setters
}

app:
  session-timeout: 30m  # 30分钟
  cache-expire: 24h     # 24小时
  data-retention: 30d   # 30天

app:
  session-timeout: 1800s    # 秒
  cache-expire: 86400000ms  # 毫秒
  connection-timeout: 5m    # 分钟
  token-validity: 7d        # 天

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    
    /**
     * 最大文件大小
     */
    private DataSize maxFileSize = DataSize.ofMegabytes(10);
    
    /**
     * 缓冲区大小
     */
    private DataSize bufferSize = DataSize.ofKilobytes(8);
    
    // Getters and Setters
}

app:
  max-file-size: 10MB
  buffer-size: 8KB

@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    private final String endpoint;
    private final String bucket;
    private final int timeoutSeconds;
    private final boolean enableHttps;
    
    // 构造器绑定
    public StorageProperties(String endpoint, String bucket, 
                            int timeoutSeconds, boolean enableHttps) {
        this.endpoint = endpoint;
        this.bucket = bucket;
        this.timeoutSeconds = timeoutSeconds;
        this.enableHttps = enableHttps;
    }
    
    // 只有 Getters,没有 Setters
    public String getEndpoint() {
        return endpoint;
    }
    
    public String getBucket() {
        return bucket;
    }
    
    public int getTimeoutSeconds() {
        return timeoutSeconds;
    }
    
    public boolean isEnableHttps() {
        return enableHttps;
    }
}

@ConfigurationProperties(prefix = "app.storage")
public record StorageProperties(
    String endpoint,
    String bucket,
    int timeoutSeconds,
    boolean enableHttps
) {
    // Record 自动生成构造器、getters、equals、hashCode、toString
}

@SpringBootApplication
@ConfigurationPropertiesScan  // 启用配置属性扫描
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    private final String endpoint;
    private final String bucket;
    private final int timeoutSeconds;
    
    // 使用 @DefaultValue 指定默认值
    public StorageProperties(
        String endpoint, 
        String bucket,
        @DefaultValue("5") int timeoutSeconds
    ) {
        this.endpoint = endpoint;
        this.bucket = bucket;
        this.timeoutSeconds = timeoutSeconds;
    }
    
    // Getters
}

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

@ConfigurationProperties(prefix = "app.storage")
@RefreshScope  // 支持动态刷新
public class StorageProperties {
    
    private String endpoint;
    private String bucket;
    
    // Getters and Setters
}

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

@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    private volatile String endpoint;
    private volatile String bucket;
    
    // Getters and Setters
}

@Service
public class ConfigRefreshService {
    
    @Autowired
    private Environment environment;
    
    @Autowired
    private StorageProperties storageProperties;
    
    public void refreshConfig() {
        String newEndpoint = environment.getProperty("app.storage.endpoint");
        String newBucket = environment.getProperty("app.storage.bucket");
        
        storageProperties.setEndpoint(newEndpoint);
        storageProperties.setBucket(newBucket);
    }
}

application.yml           # 通用配置
application-dev.yml       # 开发环境
application-test.yml      # 测试环境
application-prod.yml      # 生产环境

# application.yml
spring:
  profiles:
    active: dev  # 激活 dev 环境

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

export SPRING_PROFILES_ACTIVE=prod
java -jar myapp.jar

# application.yml (通用配置)
spring:
  application:
    name: myapp
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver

server:
  port: 8080

# application-dev.yml (开发环境)
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/myapp_dev
    username: root
    password: root

logging:
  level:
    com.example: DEBUG

# application-prod.yml (生产环境)
spring:
  datasource:
    url: jdbc:mysql://prod-db.example.com:3306/myapp
    username: ${DB_USERNAME}  # 从环境变量读取
    password: ${DB_PASSWORD}

logging:
  level:
    com.example: INFO
    org.springframework: WARN

server:
  port: 80

# application.yml
spring:
  profiles:
    active: dev
    group:
      dev: 
        - dev
        - local
      prod:
        - prod
        - monitoring

# application-local.yml
app:
  cache:
    type: local

# application-monitoring.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/myapp_dev
    username: root
    password: root
    hikari:
      maximum-pool-size: 5
  
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update

logging:
  level:
    com.example: DEBUG
    org.springframework.web: DEBUG

server:
  port: 8080
  error:
    include-stacktrace: always

app:
  storage:
    endpoint: http://localhost:9000
    bucket: dev-bucket
  security:
    enabled: false  # 开发环境关闭安全验证

spring:
  datasource:
    url: jdbc:mysql://test-db.example.com:3306/myapp_test
    username: testuser
    password: testpass
    hikari:
      maximum-pool-size: 10
  
  jpa:
    show-sql: false
    hibernate:
      ddl-auto: validate

logging:
  level:
    com.example: INFO

server:
  port: 8080

app:
  storage:
    endpoint: https://test-oss.example.com
    bucket: test-bucket
  security:
    enabled: true

spring:
  datasource:
    url: jdbc:mysql://prod-db.example.com:3306/myapp
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
    hikari:
      maximum-pool-size: 20
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
  
  jpa:
    show-sql: false
    hibernate:
      ddl-auto: none

logging:
  level:
    com.example: INFO
    org.springframework: WARN
  file:
    name: /var/log/myapp/application.log

server:
  port: 80
  error:
    include-stacktrace: never

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics

app:
  storage:
    endpoint: https://oss.example.com
    bucket: prod-bucket
  security:
    enabled: true

@Configuration
public class DataSourceConfiguration {
    
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return DataSourceBuilder.create()
            .url("jdbc:mysql://localhost:3306/myapp_dev")
            .username("root")
            .password("root")
            .build();
    }
    
    @Bean
    @Profile("prod")
    public DataSource prodDataSource(
        @Value("${spring.datasource.url}") String url,
        @Value("${spring.datasource.username}") String username,
        @Value("${spring.datasource.password}") String password
    ) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setMaximumPoolSize(20);
        return dataSource;
    }
    
    @Bean
    @Profile({"dev", "test"})
    public TestDataInitializer testDataInitializer() {
        return new TestDataInitializer();
    }
}

# application.yml
server:
  port: 8080

# 环境变量优先级更高
export SERVER_PORT=9090
java -jar myapp.jar

# 启动参数优先级最高
java -jar myapp.jar --server.port=8081

java -jar myapp.jar \
  --server.port=8081 \
  --spring.profiles.active=prod \
  --app.storage.endpoint=https://oss.example.com

export SERVER_PORT=8081
export SPRING_PROFILES_ACTIVE=prod
export APP_STORAGE_ENDPOINT=https://oss.example.com

java -jar myapp.jar

java -Dserver.port=8081 \
     -Dspring.profiles.active=prod \
     -Dapp.storage.endpoint=https://oss.example.com \
     -jar myapp.jar

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        System.setProperty("server.port", "8081");
        SpringApplication.run(Application.class, args);
    }
}

@Configuration
@PropertySource("classpath:custom-config.properties")
public class CustomConfiguration {
    
    @Value("${custom.property}")
    private String customProperty;
}

# application.yml
spring:
  datasource:
    url: jdbc:mysql://prod-db.example.com:3306/myapp
    username: prod_user

# application-dev.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/myapp_dev
    username: root
    # 没有配置 password,会继承 application.yml 中的配置

# application-dev.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/myapp_dev
    username: root
    password: root  # 显式配置,避免继承

# application-prod.yml
spring:
  datasource:
    url: jdbc:mysql://prod-db.example.com:3306/myapp
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}

export DB_USERNAME=prod_user
export DB_PASSWORD=prod_password

java -jar myapp.jar

apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
data:
  username: cHJvZF91c2Vy
  password: cHJvZF9wYXNzd29yZA==
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        env:
        - name: DB_USERNAME
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: username
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: password

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

# bootstrap.yml
spring:
  cloud:
    config:
      uri: https://config-server.example.com
      name: myapp
      profile: prod
      label: main

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

# bootstrap.yml
spring:
  cloud:
    vault:
      uri: https://vault.example.com
      token: ${VAULT_TOKEN}
      scheme: http
      kv:
        enabled: true
        backend: secret
        application-name: myapp

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

# application-prod.yml
spring:
  datasource:
    username: ENC(G6N718UuyPE5bHyWKyuLQSm02auQPUtm)
    password: ENC(6ZaM9vGmPvB3q3Zv3X2Y3g==)

java -cp jasypt-1.9.3.jar \
  org.jasypt.intf.cli.JasyptPBEStringEncryptionCLI \
  input="prod_password" \
  password=my-secret-key \
  algorithm=PBEWithMD5AndDES

java -jar myapp.jar -Djasypt.encryptor.password=my-secret-key

# 1. 查看当前激活的 Profile
curl http://localhost:8080/actuator/env | jq '.activeProfiles'

# 2. 查看配置来源
curl http://localhost:8080/actuator/env | jq '.propertySources'

# 3. 查看具体配置值
curl http://localhost:8080/actuator/env/app.storage.endpoint

# 4. 启用调试日志
java -jar myapp.jar --debug

@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    private int timeoutSeconds = 5;
    
    // 错误：配置文件中的值不是数字
    // app.storage.timeout-seconds: abc
}

# 查看配置值
curl http://localhost:8080/actuator/env/app.storage.timeout-seconds

# 查看绑定报告
curl http://localhost:8080/actuator/configprops

@RestController
public class ConfigDebugController {
    
    @Autowired
    private Environment environment;
    
    @GetMapping("/debug/config")
    public Map<String, Object> debugConfig() {
        Map<String, Object> result = new HashMap<>();
        
        // 查看配置值
        result.put("server.port", environment.getProperty("server.port"));
        result.put("spring.profiles.active", 
            String.valueOf(environment.getActiveProfiles()));
        
        // 查看配置来源
        if (environment instanceof ConfigurableEnvironment) {
            ConfigurableEnvironment ce = (ConfigurableEnvironment) environment;
            List<String> sources = ce.getPropertySources().stream()
                .map(PropertySource::getName)
                .collect(Collectors.toList());
            result.put("propertySources", sources);
        }
        
        return result;
    }
}

management:
  endpoints:
    web:
      exposure:
        include: env,configprops

{
  "activeProfiles": ["dev"],
  "propertySources": [
    {
      "name": "configurationProperties",
      "properties": {
        "server.port": {
          "value": "8080",
          "origin": "class path resource [application-dev.yml]:2:9"
        }
      }
    }
  ]
}

{
  "contexts": {
    "application": {
      "beans": {
        "storageProperties": {
          "prefix": "app.storage",
          "properties": {
            "endpoint": "https://oss.example.com",
            "bucket": "dev-bucket",
            "timeoutSeconds": 10
          }
        }
      }
    }
  }
}

java -jar myapp.jar --debug

@ConfigurationProperties(prefix = "app.storage")
@Validated
public class StorageProperties {
    
    /**
     * 存储服务提供商
     */
    @NotNull
    private StorageProvider provider = StorageProvider.ALIYUN;
    
    /**
     * 存储服务端点
     */
    @NotBlank
    private String endpoint;
    
    /**
     * 存储桶名称
     */
    @NotBlank
    private String bucket;
    
    /**
     * 访问密钥ID
     */
    @NotBlank
    private String accessKeyId;
    
    /**
     * 访问密钥Secret
     */
    @NotBlank
    private String accessKeySecret;
    
    /**
     * 超时时间(秒)
     */
    @Min(1)
    @Max(60)
    private int timeoutSeconds = 5;
    
    /**
     * 最大文件大小(MB)
     */
    @Min(1)
    @Max(100)
    private int maxFileSizeMb = 10;
    
    /**
     * 允许的文件类型
     */
    private List<String> allowedTypes = Arrays.asList("jpg", "png", "gif", "pdf");
    
    // Getters and Setters
    
    public enum StorageProvider {
        ALIYUN, TENCENT, AWS, MINIO
    }
}

@Configuration
@EnableConfigurationProperties(StorageProperties.class)
public class StorageConfiguration {
    
    @Bean
    public StorageService storageService(StorageProperties properties) {
        switch (properties.getProvider()) {
            case ALIYUN:
                return new AliyunStorageService(properties);
            case TENCENT:
                return new TencentStorageService(properties);
            case AWS:
                return new AwsStorageService(properties);
            case MINIO:
                return new MinioStorageService(properties);
            default:
                throw new IllegalArgumentException("Unsupported storage provider");
        }
    }
}

@Service
public class FileService {
    
    private final StorageService storageService;
    
    public FileService(StorageService storageService) {
        this.storageService = storageService;
    }
    
    public String uploadFile(MultipartFile file) {
        // 使用统一的存储服务
        return storageService.upload(file);
    }
}

@ConfigurationProperties(prefix = "app.database")
public class DatabaseProperties {
    
    /**
     * 环境标识
     */
    @NotNull
    private String environment;
    
    /**
     * 数据库连接信息
     */
    private ConnectionConfig connection = new ConnectionConfig();
    
    /**
     * 连接池配置
     */
    private PoolConfig pool = new PoolConfig();
    
    // Getters and Setters
    
    public static class ConnectionConfig {
        
        private String url;
        private String username;
        private String password;
        private String driverClassName = "com.mysql.cj.jdbc.Driver";
        
        // Getters and Setters
    }
    
    public static class PoolConfig {
        
        private int maximumPoolSize = 10;
        private int minimumIdle = 5;
        private long connectionTimeout = 30000;
        private long idleTimeout = 600000;
        private long maxLifetime = 1800000;
        
        // Getters and Setters
    }
}

# application-dev.yml
app:
  database:
    environment: dev
    connection:
      url: jdbc:mysql://localhost:3306/myapp_dev
      username: root
      password: root
    pool:
      maximum-pool-size: 5
      minimum-idle: 2

# application-prod.yml
app:
  database:
    environment: prod
    connection:
      url: jdbc:mysql://prod-db.example.com:3306/myapp
      username: ${DB_USERNAME}
      password: ${DB_PASSWORD}
    pool:
      maximum-pool-size: 20
      minimum-idle: 10

@Component
public class DatabaseEnvironmentValidator implements ApplicationRunner {
    
    @Autowired
    private DatabaseProperties databaseProperties;
    
    @Override
    public void run(ApplicationArguments args) {
        String env = databaseProperties.getEnvironment();
        String activeProfile = Arrays.toString(
            environment.getActiveProfiles());
        
        log.info("Database Environment: {}, Active Profile: {}", 
            env, activeProfile);
        
        // 验证环境一致性
        if (activeProfile.contains("prod") && !"prod".equals(env)) {
            throw new IllegalStateException(
                "生产环境必须使用生产数据库配置!");
        }
    }
}

@ConfigurationProperties(prefix = "app.feature")
@RefreshScope  // 支持动态刷新
public class FeatureProperties {
    
    /**
     * 限流配置
     */
    private RateLimitConfig rateLimit = new RateLimitConfig();
    
    /**
     * 线程池配置
     */
    private ThreadPoolConfig threadPool = new ThreadPoolConfig();
    
    /**
     * 灰度开关
     */
    private Map<String, Boolean> graySwitches = new HashMap<>();
    
    /**
     * 功能开关
     */
    private Map<String, Boolean> featureFlags = new HashMap<>();
    
    // Getters and Setters
    
    public static class RateLimitConfig {
        
        /**
         * 全局QPS限制
         */
        private int globalQps = 1000;
        
        /**
         * 单用户QPS限制
         */
        private int userQps = 100;
        
        /**
         * IP黑名单
         */
        private List<String> ipBlacklist = new ArrayList<>();
        
        // Getters and Setters
    }
    
    public static class ThreadPoolConfig {
        
        private int coreSize = 10;
        private int maxSize = 20;
        private int queueCapacity = 100;
        private String threadNamePrefix = "async-";
        
        // Getters and Setters
    }
}

# application.yml
app:
  feature:
    rate-limit:
      global-qps: 5000
      user-qps: 200
      ip-blacklist:
        - 192.168.1.100
        - 10.0.0.50
    thread-pool:
      core-size: 20
      max-size: 50
      queue-capacity: 200
    gray-switches:
      new-ui: true
      recommendation-v2: false
    feature-flags:
      payment-alipay: true
      payment-wechat: true
      payment-apple: false

@RestController
@RequestMapping("/api/config")
public class ConfigController {
    
    @Autowired
    private FeatureProperties featureProperties;
    
    @PostMapping("/rate-limit")
    public String updateRateLimit(@RequestBody RateLimitRequest request) {
        // 更新限流配置
        featureProperties.getRateLimit().setGlobalQps(request.getGlobalQps());
        featureProperties.getRateLimit().setUserQps(request.getUserQps());
        
        return "Rate limit updated successfully";
    }
    
    @PostMapping("/feature-flag/{name}")
    public String toggleFeatureFlag(
        @PathVariable String name, 
        @RequestParam boolean enabled
    ) {
        featureProperties.getFeatureFlags().put(name, enabled);
        return "Feature flag " + name + " set to " + enabled;
    }
}

# 搜索所有 @Value 引用
grep -r "@Value" src/ | grep -o '"\${[^}]*}"' | sort | uniq

@ConfigurationProperties(prefix = "app")
public class AppConfig {
    
    private Storage storage = new Storage();
    private Security security = new Security();
    private Cache cache = new Cache();
    
    // Getters and Setters
    
    public static class Storage {
        private String endpoint;
        private String bucket;
        private int timeoutSeconds = 5;
        
        // Getters and Setters
    }
    
    public static class Security {
        private boolean enabled = true;
        private String secretKey;
        private long tokenValidity = 3600;
        
        // Getters and Setters
    }
    
    public static class Cache {
        private boolean enabled = true;
        private int expireMinutes = 30;
        
        // Getters and Setters
    }
}

// 迁移前
@Service
public class StorageService {
    @Value("${app.storage.endpoint}")
    private String endpoint;
    
    @Value("${app.storage.bucket}")
    private String bucket;
    
    @Value("${app.storage.timeout-seconds:5}")
    private int timeoutSeconds;
}

// 迁移后
@Service
public class StorageService {
    
    private final AppConfig.Storage storage;
    
    public StorageService(AppConfig appConfig) {
        this.storage = appConfig.getStorage();
    }
    
    public void upload() {
        String endpoint = storage.getEndpoint();
        String bucket = storage.getBucket();
        int timeout = storage.getTimeoutSeconds();
        // ...
    }
}

@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {
    
    /**
     * 应用名称
     */
    @NotBlank(message = "应用名称不能为空")
    @Pattern(regexp = "^[a-z][a-z0-9-]{2,31}$", 
             message = "应用名称必须以小写字母开头,3-32个字符")
    private String name;
    
    /**
     * 应用版本
     */
    @Pattern(regexp = "^\\d+\\.\\d+\\.\\d+$", 
             message = "版本号格式必须为 x.y.z")
    private String version;
    
    /**
     * 服务器列表
     */
    @NotEmpty(message = "至少需要配置一个服务器")
    @Size(max = 10, message = "最多配置10个服务器")
    private List<@NotBlank String> servers;
    
    /**
     * 数据库配置
     */
    @NotNull
    @Valid
    private Database database;
    
    public static class Database {
        
        @NotBlank
        private String url;
        
        @NotBlank
        private String username;
        
        @Min(value = 1, message = "连接池大小至少为1")
        @Max(value = 100, message = "连接池大小最多为100")
        private int maxPoolSize = 10;
        
        // Getters and Setters
    }
    
    // Getters and Setters
}

@ConfigurationProperties(prefix = "app.storage")
public class StorageProperties {
    
    /**
     * 存储服务端点URL
     * 
     * 示例:
     * - 阿里云OSS: https://oss-cn-hangzhou.aliyuncs.com
     * - 腾讯云COS: https://cos.ap-guangzhou.myqcloud.com
     * - MinIO: http://localhost:9000
     * 
     * @see <a href="https://help.aliyun.com/document_detail/31837.html">阿里云OSS文档</a>
     */
    @NotBlank(message = "存储端点不能为空")
    private String endpoint;
    
    /**
     * 存储桶名称
     * 
     * 命名规则:
     * - 只能包含小写字母、数字和短横线
     * - 必须以小写字母或数字开头和结尾
     * - 长度在3-63个字符之间
     */
    @NotBlank(message = "存储桶名称不能为空")
    @Pattern(regexp = "^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$", 
             message = "存储桶名称格式不正确")
    private String bucket;
    
    // Getters and Setters
}

@ConfigurationProperties(prefix = "app.storage")
@RefreshScope
public class StorageProperties {
    // 配置更新后会自动刷新
}

@ConfigurationProperties(prefix = "app.storage")
@Validated
public class StorageProperties {
    
    @NotBlank(message = "端点不能为空")
    @Pattern(regexp = "^https?://.*", message = "必须是有效URL")
    private String endpoint;
    
    @Min(1) @Max(60)
    private int timeoutSeconds = 5;
}