How to Use Spring Profiles in Your Spring Boot Application

Spring Profiles provide a powerful way to segregate parts of your application configuration and make it available only in certain environments. This feature is especially useful for handling different configurations for development, testing, and production environments without changing your code.

What are Spring Profiles?

Spring Profiles allow you to register beans conditionally, depending on the active profile. This means you can define multiple beans of the same type and specify which one should be active in a given environment.

Setting Up Spring Profiles

1. Creating Configuration Files

Spring Boot uses a set of application-{profile}.properties or application-{profile}.yml files for configuration. These files contain profile-specific configurations and are loaded based on the active profile.

Default Configuration (application.yml)

spring:
  application:
    name: MySpringApp

server:
  port: 8080  # Default port

Development Configuration (application-dev.yml)

spring:
  datasource:
    url: jdbc:h2:mem:devdb
    username: sa
    password: ""
    driver-class-name: org.h2.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

server:
  port: 8081  # Development port

Production Configuration (application-prod.yml)

spring:
  datasource:
    url: jdbc:mysql://prod-db-server:3306/proddb
    username: prod_user
    password: prod_password
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false

server:
  port: 8082  # Production port

Activating Spring Profiles

2. Activating Profiles via Command Line

You can activate a profile by using the --spring.profiles.active parameter when running your Spring Boot application:

java -jar my-spring-app.jar --spring.profiles.active=dev

3. Activating Profiles via Application Properties

Alternatively, you can specify the active profile in your application.yml file:

spring:
  profiles:
    active: dev  # or prod

4. Activating Profiles via Environment Variables

You can also set the active profile using an environment variable:

export SPRING_PROFILES_ACTIVE=dev

Using Profiles in Code

Spring provides a @Profile annotation to conditionally register beans based on the active profile. Here’s an example:

Example Configuration Classes

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration
public class AppConfig {

    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return new HikariDataSource();  // Development-specific DataSource
    }

    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        return new HikariDataSource();  // Production-specific DataSource
    }
}

In this example, devDataSource bean will only be created when the dev profile is active, and prodDataSource bean will be created when the prod profile is active.

Testing Profile-Specific Beans

When writing tests, you can specify which profiles should be active using the @ActiveProfiles annotation:

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;

@SpringBootTest
@ActiveProfiles("dev")
public class DevProfileTests {

    @Autowired
    private DataSource dataSource;

    @Test
    public void testDataSource() {
        // Test code using the development DataSource
    }
}

Profile-Specific Properties

Sometimes, you might want to load different properties files based on the active profile. You can use @PropertySource annotation to achieve this:

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource("classpath:application-${spring.profiles.active}.properties")
public class PropertyConfig {
}

Conclusion

Spring Profiles are a robust and flexible way to manage different configurations for various environments. By segregating your configuration properties and beans based on profiles, you can ensure that your application behaves correctly in each environment, whether it's development, testing, or production. Using the techniques outlined in this article, you can easily set up and manage profiles in your Spring Boot application.