Centralized Configuration

# Precedence, highest to lowest (abridged)
#  1. Command-line arguments            --server.port=9090
#  2. SPRING_APPLICATION_JSON           {"server":{"port":9090}}
#  3. Java system properties            -Dserver.port=9090
#  4. OS environment variables          SERVER_PORT=9090
#  5. Config data outside the jar       ./config/application-prod.yml
#  6. Config data inside the jar        classpath:application-prod.yml
#  7. Remote config (config import)     configserver:, kubernetes:
#  8. Packaged application.yml
#  9. @PropertySource, SpringApplication defaults
#
# Within each location, profile-specific files override the base file.

# Relaxed binding: one property, several spellings
#   application.yml / .properties   spring.datasource.max-pool-size   (canonical, use this)
#   Environment variable            SPRING_DATASOURCE_MAXPOOLSIZE
#   System property                 -Dspring.datasource.maxPoolSize
# Dots become underscores and everything is upper-cased in env vars.

# application.yml: shared by every environment
spring:
  application:
    name: order-service
  jpa:
    open-in-view: false
    hibernate:
      ddl-auto: validate

app:
  pagination:
    default-page-size: 20
    max-page-size: 100

---
# application-dev.yml: activated with SPRING_PROFILES_ACTIVE=dev
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/orders_dev
    username: dev
    password: dev
  jpa:
    show-sql: true

---
# application-prod.yml: no credentials here, only references
spring:
  datasource:
    url: ${DATABASE_URL}
    username: ${DATABASE_USER}
    password: ${DATABASE_PASSWORD}

# Activate several profiles at once; later profiles win on conflicts:
#   SPRING_PROFILES_ACTIVE=prod,eu-west

// Immutable, validated properties (Spring Boot 3)
@ConfigurationProperties(prefix = "app.payments")
@Validated
public record PaymentProperties(
        @NotBlank String gatewayUrl,
        @NotBlank String apiKey,
        @DefaultValue("30s") Duration timeout,
        @DefaultValue("false") boolean sandboxMode,
        @Valid @DefaultValue Retry retry,
        @NotEmpty @DefaultValue({"USD", "EUR", "GBP"}) List<String> supportedCurrencies) {

    public record Retry(
            @Min(0) @Max(10) @DefaultValue("3") int maxAttempts,
            @DefaultValue("100ms") Duration initialDelay,
            @DecimalMin("1.0") @DefaultValue("2.0") double multiplier) {
    }
}

// Register every @ConfigurationProperties class under this package
@SpringBootApplication
@ConfigurationPropertiesScan
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

// Usage: depends on a typed object, not on property strings
@Service
public class PaymentService {

    private final PaymentProperties config;

    public PaymentService(PaymentProperties config) {
        this.config = config;
    }

    public PaymentResponse charge(BigDecimal amount, String currency) {
        if (!config.supportedCurrencies().contains(currency)) {
            throw new UnsupportedCurrencyException(currency);
        }
        // config.gatewayUrl(), config.timeout(), config.retry().maxAttempts() ...
    }
}

# application.yml
# app:
#   payments:
#     gateway-url: https://payments.example.com/v2
#     api-key: ${PAYMENT_API_KEY}
#     timeout: 15s
#     retry:
#       max-attempts: 3
#       initial-delay: 200ms

// Server: a tiny application
@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}

# Server application.yml
server:
  port: 8888
spring:
  cloud:
    config:
      server:
        git:
          uri: https://git.example.com/platform/config-repo.git
          default-label: main
          search-paths: "{application}"     # one folder per service
          clone-on-start: true
          timeout: 10

# Repository layout
#   order-service/
#     application.yml         shared by all profiles
#     application-prod.yml    production overrides
#   payment-service/
#     application.yml

# Client application.yml (Spring Boot 2.4+ style, no bootstrap.yml)
spring:
  application:
    name: order-service
  config:
    import: "configserver:http://config-server:8888"
  cloud:
    config:
      fail-fast: true
      retry:
        max-attempts: 6
        initial-interval: 1000

management:
  endpoints:
    web:
      exposure:
        include: health,refresh,env

// Mutable on purpose: the bean is rebound when the environment changes
@ConfigurationProperties(prefix = "app.features")
public class FeatureFlags {

    private boolean newCheckoutFlow = false;
    private int newCheckoutRollout = 0;            // percentage, 0 to 100
    private Set<String> betaUsers = new HashSet<>();

    public boolean isNewCheckoutFlow() { return newCheckoutFlow; }
    public void setNewCheckoutFlow(boolean v) { this.newCheckoutFlow = v; }

    public int getNewCheckoutRollout() { return newCheckoutRollout; }
    public void setNewCheckoutRollout(int v) { this.newCheckoutRollout = v; }

    public Set<String> getBetaUsers() { return betaUsers; }
    public void setBetaUsers(Set<String> v) { this.betaUsers = v; }
}

@Service
public class FeatureFlagService {

    private final FeatureFlags flags;

    public FeatureFlagService(FeatureFlags flags) {
        this.flags = flags;
    }

    public boolean isNewCheckoutEnabled(long userId) {
        if (flags.isNewCheckoutFlow()) {
            return true;                                   // fully released
        }
        if (flags.getBetaUsers().contains(String.valueOf(userId))) {
            return true;                                   // early-access allowlist
        }
        int rollout = flags.getNewCheckoutRollout();
        return rollout > 0 && Math.floorMod(Long.hashCode(userId), 100) < rollout;
    }
}

@RestController
@RequestMapping("/api/v1/checkout")
public class CheckoutController {

    private final FeatureFlagService flags;
    private final CheckoutService checkout;

    public CheckoutController(FeatureFlagService flags, CheckoutService checkout) {
        this.flags = flags;
        this.checkout = checkout;
    }

    @PostMapping
    public CheckoutResponse checkout(@RequestBody @Valid CheckoutRequest request,
                                     @AuthenticationPrincipal AppUser user) {
        return flags.isNewCheckoutEnabled(user.getId())
                ? checkout.processNew(request)
                : checkout.processLegacy(request);
    }
}

# Config repo, order-service/application-prod.yml
# app:
#   features:
#     new-checkout-rollout: 25
#     beta-users: ["1001", "1002"]
# Commit, then POST /actuator/refresh on the instances (or publish via Spring Cloud Bus).

# ConfigMap: non-sensitive settings
apiVersion: v1
kind: ConfigMap
metadata:
  name: order-service-config
  namespace: production
data:
  application.yml: |
    app:
      features:
        new-checkout-rollout: 10
      payments:
        gateway-url: https://payments.prod.example.com
        timeout: 15s
---
# Secret: created by your pipeline or an external secrets operator,
# never committed to Git with real values
apiVersion: v1
kind: Secret
metadata:
  name: order-service-secrets
  namespace: production
type: Opaque
stringData:
  spring.datasource.password: "<injected-by-pipeline>"
  app.payments.api-key: "<injected-by-pipeline>"
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  template:
    spec:
      containers:
        - name: order-service
          image: registry.example.com/order-service:1.4.2
          env:
            - name: SPRING_PROFILES_ACTIVE
              value: prod
            - name: SPRING_CONFIG_IMPORT
              value: "optional:file:/config/application.yml,optional:configtree:/secrets/"
          volumeMounts:
            - name: config
              mountPath: /config
              readOnly: true
            - name: secrets
              mountPath: /secrets
              readOnly: true
      volumes:
        - name: config
          configMap:
            name: order-service-config
        - name: secrets
          secret:
            secretName: order-service-secrets

# Optional: live reload with Spring Cloud Kubernetes
# Dependency: org.springframework.cloud:spring-cloud-starter-kubernetes-client-config
# The service account needs RBAC permission to get/list/watch configmaps and secrets.
spring:
  cloud:
    kubernetes:
      reload:
        enabled: true
        strategy: refresh        # rebinds properties without restarting
        mode: event              # or "polling" if watch RBAC is not allowed
        # period: 15000          # only used with mode: polling

# application.yml: hardening the actuator
management:
  endpoint:
    env:
      show-values: NEVER           # default is NEVER in Boot 3; do not loosen it in prod
    configprops:
      show-values: NEVER
  endpoints:
    web:
      exposure:
        include: health,info       # expose env/refresh only on a protected management port
  server:
    port: 9090                     # separate port, not published outside the cluster

# Spring Cloud Vault: pull secrets at startup
spring:
  config:
    import: "vault://"
  cloud:
    vault:
      uri: https://vault.example.com:8200
      authentication: KUBERNETES
      kubernetes:
        role: order-service
      kv:
        enabled: true
        backend: secret
        default-context: order-service
      # Dynamic credentials: a fresh DB user per instance, rotated automatically
      database:
        enabled: true
        role: order-service-rw
        backend: database

// Keep secrets out of logs
public record PaymentProperties(
        @NotBlank String gatewayUrl,
        @NotBlank String apiKey /* ... */) {

    @Override
    public String toString() {
        return "PaymentProperties[gatewayUrl=" + gatewayUrl + ", apiKey=****]";
    }
}

@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {

    @Valid @NotNull private Database database = new Database();
    @Valid @NotNull private Security security = new Security();

    public static class Database {
        @NotBlank(message = "app.database.url must be configured")
        private String url;

        @Min(value = 1, message = "Pool size must be at least 1")
        @Max(value = 100, message = "Pool size must not exceed 100")
        private int poolSize = 10;

        @DurationMin(millis = 100)
        private Duration connectionTimeout = Duration.ofSeconds(30);

        // getters and setters omitted
    }

    public static class Security {
        @NotBlank
        @Size(min = 32, message = "JWT secret must be at least 32 characters")
        private String jwtSecret;

        @DurationMin(minutes = 1)
        @DurationMax(hours = 24)
        private Duration accessTokenExpiry = Duration.ofMinutes(15);

        // getters and setters omitted
    }

    // getters and setters omitted
}

// Cross-field and profile-aware rule: validate against the Environment
@Component
public class ProductionSafetyCheck implements InitializingBean {

    private final AppProperties properties;
    private final Environment environment;

    public ProductionSafetyCheck(AppProperties properties, Environment environment) {
        this.properties = properties;
        this.environment = environment;
    }

    @Override
    public void afterPropertiesSet() {
        if (environment.acceptsProfiles(Profiles.of("prod"))
                && properties.getSecurity().getAccessTokenExpiry().compareTo(Duration.ofHours(1)) >= 0) {
            throw new IllegalStateException(
                "app.security.access-token-expiry must be under 1 hour in the prod profile");
        }
    }
}

// What a failed binding looks like at startup:
//
//   Binding to target AppProperties failed:
//     Property: app.security.jwtSecret
//     Value: "short"
//     Reason: JWT secret must be at least 32 characters
//
// The context never finishes starting, so the readiness probe never passes
// and Kubernetes keeps the bad version out of rotation.