Spring Boot Profiles

Introduction

In this article, we will explore the concept of profiles in Spring Boot and how they can be used to manage different configurations for different environments. We will start by understanding what profiles are and why they are useful. Then, we will delve into the implementation details and see some code examples.

What are Profiles?

Profiles in Spring Boot allow us to define different sets of configurations for different environments. These configurations can include properties, beans, and other components that are specific to a particular environment, such as development, testing, or production.

Profiles provide a way to manage the application's behavior based on the environment it is running in. By using profiles, we can easily switch between different configurations without modifying the code.

How to Use Profiles in Spring Boot?

To use profiles in Spring Boot, we need to follow these steps:

  1. Define profiles in the application properties file.
  2. Create different configuration files for each profile.
  3. Activate profiles.

Step 1: Define Profiles

Profiles can be defined in the application.properties file using the spring.profiles.active property. This property can have multiple values separated by commas.

Here is an example of defining profiles:

spring.profiles.active=dev,test

In this example, we have defined two profiles: dev and test. These profiles can be activated individually or together.

Step 2: Create Configuration Files

Next, we need to create separate configuration files for each profile. The naming convention for these files is application-{profile}.properties. For example, if our profile is dev, the configuration file should be named application-dev.properties.

In these configuration files, we can override the properties defined in the main application.properties file. This allows us to have different values for the same properties in different environments.

Here is an example of a configuration file for the dev profile:

# application-dev.properties

spring.datasource.url=jdbc:mysql://localhost:3306/dev_database
spring.datasource.username=dev_user
spring.datasource.password=dev_password

Step 3: Activate Profiles

Finally, we need to activate the profiles in our application. This can be done in multiple ways:

3.1 Command Line

We can activate profiles using command line arguments when starting the application. For example, to activate the dev profile, we can use the following command:

java -jar myapplication.jar --spring.profiles.active=dev
3.2 Environment Variable

We can also activate profiles using environment variables. For example, we can set the SPRING_PROFILES_ACTIVE environment variable to dev before starting the application.

3.3 JVM System Property

Profiles can also be activated using JVM system properties. For example, we can pass -Dspring.profiles.active=dev as a system property when starting the application.

3.4 Default Profiles

If no profiles are specified, Spring Boot will use the default profile defined in the application.properties file. The default profile can be set using the spring.profiles.default property.

Code Example

Let's see a code example to understand how profiles work in Spring Boot.

Application Configuration

Suppose we have a Spring Boot application that connects to a database and performs some operations. We want to have different database configurations for the dev and test environments.

Development Configuration

For the dev profile, we want to use an in-memory H2 database. So, we need to create a configuration class that sets up the H2 datasource.

@Configuration
@Profile("dev")
public class DevDatabaseConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
                .setType(EmbeddedDatabaseType.H2)
                .addScript("classpath:db/schema.sql")
                .addScript("classpath:db/data.sql")
                .build();
    }
}
Testing Configuration

For the test profile, we want to use an embedded PostgreSQL database. So, we need to create another configuration class for the testing environment.

@Configuration
@Profile("test")
public class TestDatabaseConfig {

    @Bean
    public DataSource dataSource() {
        // Configure and return the embedded PostgreSQL datasource
    }
}

Profile Activation

We can activate profiles using any of the methods mentioned earlier. For simplicity, let's activate the dev profile using the command line.

java -jar myapplication.jar --spring.profiles.active=dev

Usage in Code

Now, we can use the database configuration based on the active profile. For example, if we have a service class that requires a DataSource bean, we can inject it using the @Autowired annotation.

@Service
public class MyService {

    private final DataSource dataSource;

    @Autowired
    public MyService(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    // ...
}

Conclusion

In this article, we explored the concept of profiles in Spring Boot and learned how they can be used to manage different configurations for different environments. We saw how to define profiles, create configuration files, and activate profiles using various methods. We also saw a code example that demonstrated the usage of profiles in a Spring Boot application