Configuration and Profiles in Spring Boot

# application.yml — the base configuration, applies to all profiles
spring:
  application:
    name: order-service
 
server:
  port: 8080
  shutdown: graceful
 
logging:
  level:
    root: INFO
    com.acme.orders: DEBUG
 
management:
  endpoints:
    web:
      exposure:
        include: health, info, metrics, prometheus
  endpoint:
    health:
      show-details: when-authorized
 
order-service:
  payment:
    timeout: 5s
    retry-attempts: 3
  inventory:
    reservation-hold-minutes: 15

# Equivalent in .properties format (less common in modern Spring Boot, but still supported)
spring.application.name=order-service
server.port=8080
order-service.payment.timeout=5s
order-service.payment.retry-attempts=3

@ConfigurationProperties(prefix = "order-service.payment")
public record PaymentProperties(
        @DurationUnit(ChronoUnit.SECONDS) Duration timeout,
        int retryAttempts,
        String defaultCurrency
) {
    // Compact constructor for validation/defaults
    public PaymentProperties {
        if (retryAttempts < 0) {
            throw new IllegalArgumentException("retryAttempts must not be negative");
        }
        if (defaultCurrency == null) {
            defaultCurrency = "USD";
        }
    }
}

@Configuration
@EnableConfigurationProperties(PaymentProperties.class)
public class PaymentConfig {
 
    @Bean
    public PaymentGateway paymentGateway(PaymentProperties properties, RestClient.Builder builder) {
        RestClient client = builder
            .requestFactory(ClientHttpRequestFactorySettings.DEFAULTS
                .withConnectTimeout(properties.timeout())
                .withReadTimeout(properties.timeout()))
            .build();
        return new HttpPaymentGateway(client, properties.retryAttempts(), properties.defaultCurrency());
    }
}

order-service:
  payment:
    timeout: 5s
    retry-attempts: 3
    default-currency: USD

// @Value works but doesn't scale — no grouping, no validation, easy to typo the key
@Service
public class LegacyPaymentService {
    @Value("${order-service.payment.retry-attempts:3}")
    private int retryAttempts;
}

@ConfigurationProperties(prefix = "order-service.inventory")
@Validated
public record InventoryProperties(
        @Min(1) @Max(1440) int reservationHoldMinutes,
        @NotBlank String warehouseRegion
) {}

# application.yml — shared defaults + profile-specific overrides using YAML documents
spring:
  application:
    name: order-service
 
---
spring:
  config:
    activate:
      on-profile: dev
datasource:
  url: jdbc:h2:mem:orders
logging:
  level:
    com.acme.orders: DEBUG
 
---
spring:
  config:
    activate:
      on-profile: staging
datasource:
  url: jdbc:postgresql://staging-db.internal:5432/orders
 
---
spring:
  config:
    activate:
      on-profile: prod
datasource:
  url: jdbc:postgresql://prod-db.internal:5432/orders
logging:
  level:
    com.acme.orders: WARN

# Activating a profile
java -jar order-service.jar --spring.profiles.active=prod
 
# Or via environment variable (typical in containers)
export SPRING_PROFILES_ACTIVE=prod
java -jar order-service.jar
 
# Multiple profiles compose together
java -jar order-service.jar --spring.profiles.active=prod,metrics

@Configuration
public class NotificationConfig {
 
    @Bean
    @Profile("prod")
    public NotificationChannel productionEmailChannel(SesClient sesClient) {
        return new SesEmailChannel(sesClient); // real AWS SES integration
    }
 
    @Bean
    @Profile({"dev", "test"})
    public NotificationChannel loggingOnlyChannel() {
        return (to, message) -> log.info("Would send to {}: {}", to, message); // no real email sent
    }
}

# Kubernetes ConfigMap example — same relaxed binding rules apply
apiVersion: v1
kind: ConfigMap
metadata:
  name: order-service-config
data:
  SPRING_PROFILES_ACTIVE: "prod"
  ORDER_SERVICE_PAYMENT_TIMEOUT: "8s"
  ORDER_SERVICE_PAYMENT_RETRY_ATTEMPTS: "5"

# NEVER do this — plaintext secret committed to source control
datasource:
  url: jdbc:postgresql://prod-db.internal:5432/orders
  username: admin
  password: SuperSecret123!   # DO NOT COMMIT

# application.yml references an environment variable — no secret value in the file
datasource:
  url: jdbc:postgresql://prod-db.internal:5432/orders
  username: ${DB_USERNAME}
  password: ${DB_PASSWORD}

# The actual secret is injected at deploy time, never stored in the repo
# Kubernetes: mounted from a Secret resource as env vars
# AWS: pulled from Secrets Manager / Parameter Store into ECS task definition
# Docker Compose (local only): from a gitignored .env file

@ConfigurationProperties(prefix = "order-service.features")
public record FeatureFlags(
        boolean newPricingEngine,
        boolean asyncNotifications
) {}

@Service
public class PricingService {
    private final FeatureFlags featureFlags;
    private final PricingStrategy legacyStrategy;
    private final PricingStrategy newStrategy;
 
    public Money calculatePrice(Order order) {
        PricingStrategy strategy = featureFlags.newPricingEngine() ? newStrategy : legacyStrategy;
        return strategy.compute(order);
    }
}

order-service:
  features:
    new-pricing-engine: false
    async-notifications: true

@RestController
@RefreshScope // Spring Cloud Config — bean is recreated on a /actuator/refresh call
public class PricingController {
 
    @Value("${order-service.discount.rate}")
    private double discountRate;
}