Environment & Profiles

@Service
public class ConfigurationInspector {

    private final Environment environment;

    public ConfigurationInspector(Environment environment) {
        this.environment = environment;
    }

    public void inspectProperties() {
        // Read a property (null if missing):
        String dbUrl = environment.getProperty("spring.datasource.url");

        // Read with default value:
        String port = environment.getProperty("server.port", "8080");

        // Read as specific type with default:
        Integer maxPool = environment.getProperty(
            "spring.datasource.hikari.maximum-pool-size", Integer.class, 10);

        // Require a property: throws IllegalStateException if it is absent
        String jwtSecret = environment.getRequiredProperty("app.jwt.secret");

        // Check if a property exists:
        boolean hasPoolSize = environment.containsProperty(
            "spring.datasource.hikari.maximum-pool-size");

        // Active profiles, and the default profiles (["default"] unless you changed it):
        String[] activeProfiles = environment.getActiveProfiles();
        String[] defaultProfiles = environment.getDefaultProfiles();

        // Profile expressions:
        boolean isProd = environment.acceptsProfiles(Profiles.of("prod"));
        boolean isNotProd = environment.acceptsProfiles(Profiles.of("!prod"));
        boolean isProdOrStaging = environment.acceptsProfiles(Profiles.of("prod | staging"));
        boolean isDevAndDebug = environment.acceptsProfiles(Profiles.of("dev & debug"));
    }
}

# Typical container configuration
SPRING_PROFILES_ACTIVE=prod
SERVER_PORT=9090
SPRING_DATASOURCE_URL=jdbc:postgresql://db:5432/app
SPRING_DATASOURCE_PASSWORD=change-me-via-secret-store
SPRING_DATASOURCE_HIKARI_MAXIMUMPOOLSIZE=20
APP_ORIGINS_0=https://app.example.com
APP_ORIGINS_1=https://admin.example.com

# application.properties — flat key-value pairs:
server.port=8080
server.servlet.context-path=/api

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=${DB_PASSWORD}
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5

spring.jpa.hibernate.ddl-auto=validate
spring.jpa.show-sql=false
spring.jpa.open-in-view=false

logging.level.root=INFO
logging.level.com.example=DEBUG
logging.pattern.console=%d{HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n

app.jwt.secret=${JWT_SECRET}
app.jwt.expiration=86400
spring.mail.host=smtp.gmail.com
spring.mail.port=587

# File naming convention:
# application.properties        → always loaded (base config)
# application-dev.properties    → loaded additionally when 'dev' is active
# application-prod.properties   → loaded additionally when 'prod' is active
# application-test.properties   → loaded additionally when 'test' is active

# application.properties (base — shared by all environments):
server.port=8080
spring.jpa.show-sql=false
logging.level.root=INFO
app.name=MyApplication
app.version=2.1.0

# application-dev.properties (development overrides):
spring.datasource.url=jdbc:h2:mem:devdb
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=true
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=create-drop
logging.level.com.example=DEBUG
logging.level.org.springframework.web=DEBUG
spring.mail.host=localhost
spring.mail.port=1025

# application-prod.properties (production settings):
spring.datasource.url=${DATABASE_URL}
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}
spring.datasource.hikari.maximum-pool-size=20
spring.jpa.hibernate.ddl-auto=validate
logging.level.root=WARN
logging.level.com.example=INFO
spring.mail.host=smtp.sendgrid.net
spring.mail.port=587
server.shutdown=graceful

# application-test.properties (test overrides):
spring.datasource.url=jdbc:h2:mem:testdb;MODE=MySQL
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.hibernate.ddl-auto=create-drop
spring.mail.host=localhost
app.jwt.secret=test-secret-key-for-testing-only-not-for-production
logging.level.root=WARN

# application.yml
app:
  name: MyApplication
server:
  port: 8080
---
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: jdbc:h2:mem:devdb
server:
  port: 8081
---
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: ${DATABASE_URL}
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
logging:
  level:
    root: WARN

# Method 1 — application.properties (lowest priority):
spring.profiles.active=dev

# Method 2 — environment variable (common in containers):
# SPRING_PROFILES_ACTIVE=prod

# Method 3 — JVM system property:
# java -Dspring.profiles.active=prod -jar app.jar

# Method 4 — command-line argument (highest priority of these):
# java -jar app.jar --spring.profiles.active=prod

# Several profiles — comma-separated (later profiles override earlier ones):
# spring.profiles.active=prod,metrics,eu-region

# Profile groups (Spring Boot 2.4+) — one name activates several profiles:
spring.profiles.group.production=prod,metrics,monitoring,security
spring.profiles.group.development=dev,local-db,mock-mail
# Activate with: --spring.profiles.active=production

# spring.profiles.include — adds profiles unconditionally to whatever else is active
# (not allowed inside profile-specific files since Spring Boot 2.4):
# spring.profiles.include=common-security

# Default profile — used only when NO profile is active.
# If you set nothing, Spring uses a profile literally named "default"
# and loads application-default.properties:
spring.profiles.default=dev

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        app.setAdditionalProfiles("metrics");   // added to whatever else is active
        app.run(args);
    }
}

@Component
public class ProfileLogger implements ApplicationRunner {

    private static final Logger log = LoggerFactory.getLogger(ProfileLogger.class);

    private final Environment environment;

    public ProfileLogger(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void run(ApplicationArguments args) {
        String[] profiles = environment.getActiveProfiles();
        if (profiles.length == 0) {
            log.info("No active profiles, using default profile(s): {}",
                String.join(", ", environment.getDefaultProfiles()));
        } else {
            log.info("Active profiles: {}", String.join(", ", profiles));
        }
    }
}

// @Profile on @Component — bean only created in the specified profile:
@Component
@Profile("dev")
public class MockEmailService implements EmailService {

    private static final Logger log = LoggerFactory.getLogger(MockEmailService.class);

    @Override
    public void send(String to, String subject, String body) {
        log.info("MOCK EMAIL to {}: {}", to, subject);   // nothing is sent in development
    }
}

@Component
@Profile("prod")
public class SmtpEmailService implements EmailService {

    private final JavaMailSender mailSender;   // configured by spring.mail.* properties

    public SmtpEmailService(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }

    @Override
    public void send(String to, String subject, String body) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(subject);
        message.setText(body);
        mailSender.send(message);
    }
}

// Seed data only where you mean to. "!prod" would also run in staging
// and when no profile is active.
@Component
@Profile("dev")
public class DevDataSeeder implements CommandLineRunner {

    private final UserRepository userRepository;

    public DevDataSeeder(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public void run(String... args) {
        if (userRepository.count() == 0) {
            userRepository.save(new User("admin@test.com", "Admin", "ADMIN"));
            userRepository.save(new User("user@test.com", "Test User", "USER"));
        }
    }
}

// @Profile on @Configuration — the whole class is conditional.
// Only beans that genuinely differ per environment belong here.
@Configuration
@Profile("dev")
public class DevConfiguration {

    @Bean
    public StorageService storageService() {
        return new LocalFileStorageService("/tmp/dev-uploads");
    }
}

@Configuration
@Profile("prod")
public class ProductionConfiguration {

    @Bean
    public StorageService storageService(S3Properties props) {
        return new AwsS3StorageService(props.getBucket(), props.getRegion());
    }
}

// Several profiles in one annotation — active if ANY listed profile is active:
@Component
@Profile({"dev", "test"})
public class MockPaymentService implements PaymentService {
    @Override
    public PaymentResult charge(String customerId, BigDecimal amount) {
        return new PaymentResult("mock-txn-" + UUID.randomUUID(), PaymentStatus.SUCCESS);
    }
}

// Profile expressions (Spring 5.1+). Mixing & and | needs parentheses:
@Component
@Profile("prod & !legacy")    // prod AND NOT legacy
public class ModernProdService { }

@Component
@Profile("dev | test")        // dev OR test
public class NonProdHelper { }

@Component
@Profile("(dev | test) & !offline")
public class OnlineNonProdHelper { }

// Typed properties class:
@ConfigurationProperties(prefix = "app.payment")
@Validated
public class PaymentProperties {

    @NotBlank
    private String provider;

    @NotBlank
    private String apiKey;

    private String webhookSecret;

    @Min(1) @Max(10)
    private int maxRetries = 3;

    private boolean sandboxMode = false;

    // getters and setters
}

// Register it:
@Configuration
@EnableConfigurationProperties(PaymentProperties.class)
public class PaymentConfig {

    @Bean
    public PaymentService paymentService(PaymentProperties props) {
        return switch (props.getProvider()) {
            case "stripe" -> new StripePaymentService(
                props.getApiKey(), props.getWebhookSecret(), props.isSandboxMode());
            case "paypal" -> new PaypalPaymentService(
                props.getApiKey(), props.isSandboxMode());
            default -> throw new IllegalStateException(
                "Unknown payment provider: " + props.getProvider());
        };
    }
}

// application-dev.properties:
//   app.payment.provider=stripe
//   app.payment.api-key=sk_test_abc123
//   app.payment.sandbox-mode=true
//   app.payment.max-retries=1
//
// application-prod.properties:
//   app.payment.provider=stripe
//   app.payment.api-key=${STRIPE_API_KEY}
//   app.payment.webhook-secret=${STRIPE_WEBHOOK_SECRET}
//   app.payment.sandbox-mode=false
//   app.payment.max-retries=3
//
// Startup fails fast on misconfiguration:
//   missing app.payment.provider  → bind failure (@NotBlank)
//   app.payment.max-retries=15    → bind failure (exceeds @Max(10))

# application.properties
# Local developer overrides that are never committed:
spring.config.import=optional:file:./local.properties

# Container secrets: /run/secrets/db.password becomes the property "db.password"
spring.config.import=optional:file:./local.properties,optional:configtree:/run/secrets/

spring.datasource.password=${db.password}

// @ActiveProfiles — activate profiles for a test class:
@SpringBootTest
@ActiveProfiles("test")
class UserServiceIntegrationTest {
    // Loads application-test.properties
    // Creates all @Profile("test") beans
    // Creates all @Profile("!prod") beans too
    @Autowired UserService userService;
}

// Multiple profiles:
@SpringBootTest
@ActiveProfiles({"test", "security-disabled"})
class ApiIntegrationTest {
    @Autowired MockMvc mockMvc;
}

// Override specific properties without a profile:
@SpringBootTest
@TestPropertySource(properties = {
    "app.jwt.expiration=60",
    "app.payment.sandbox-mode=true",
    "spring.jpa.show-sql=true"
})
class JwtServiceTest { }

// Same idea with a file:
@SpringBootTest
@TestPropertySource(locations = "classpath:test-overrides.properties")
class SpecialConfigTest { }

// Replace a bean with a mock:
@SpringBootTest
@ActiveProfiles("test")
class CheckoutTest {

    @MockitoBean PaymentService paymentService;

    @Test
    void checkoutSucceeds() {
        when(paymentService.charge(any(), any()))
            .thenReturn(new PaymentResult("test-txn", PaymentStatus.SUCCESS));
        // test checkout flow...
    }
}

// A test-only helper bean, imported explicitly (no profile needed):
@TestConfiguration
public class TestBeanOverrides {

    @Bean
    @Primary
    public EmailService captureEmailService() {
        return new EmailCaptor();   // captures emails for assertions
    }
}

@SpringBootTest
@ActiveProfiles("test")
@Import(TestBeanOverrides.class)
class EmailFlowTest { }

// Run slow tests only on demand (JUnit 5):
@SpringBootTest
@ActiveProfiles("integration")
@EnabledIfSystemProperty(named = "run.integration.tests", matches = "true")
class ExternalServiceIntegrationTest {
    // Runs only with -Drun.integration.tests=true
}

// Inject Environment directly:
@Service
public class FeatureFlagService {

    private final Environment environment;

    public FeatureFlagService(Environment environment) {
        this.environment = environment;
    }

    public boolean isEnabled(String featureName) {
        return environment.getProperty(
            "app.features." + featureName + ".enabled", Boolean.class, false);
    }

    public <T> T getConfig(String key, Class<T> type, T defaultValue) {
        return environment.getProperty(key, type, defaultValue);
    }
}

// EnvironmentPostProcessor — modify the environment before the context is created:
public class CustomPropertySourcePostProcessor implements EnvironmentPostProcessor {

    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment,
                                       SpringApplication application) {
        Map<String, Object> extra = loadExtraProperties();
        MapPropertySource source = new MapPropertySource("extra", extra);

        // addLast keeps command-line and environment variables in charge.
        // addFirst would override everything, including command-line arguments.
        environment.getPropertySources().addLast(source);
    }

    private Map<String, Object> loadExtraProperties() {
        return Map.of("app.region", "eu-west-1");
    }
}

// META-INF/spring.factories (one line):
// org.springframework.boot.env.EnvironmentPostProcessor=com.example.CustomPropertySourcePostProcessor

// EnvironmentAware — implement to receive the environment:
@Component
public class DynamicConfigService implements EnvironmentAware {

    private Environment environment;

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    public String getConnectionString(String serviceName) {
        String host = environment.getProperty("services." + serviceName + ".host", "localhost");
        int port = environment.getProperty("services." + serviceName + ".port", Integer.class, 8080);
        return "http://" + host + ":" + port;
    }
}