Spring Boot Profiling

What Are Profiles in Spring Boot?

Every enterprise application has many environments, like:

Dev | Test | Stage | Prod | UAT / Pre-Prod

Each environment requires a setting that is specific to them. For example, in DEV, we do not need to constantly check database consistency. Whereas in TEST and STAGE, we need to. These environments host specific configurations called Profiles.

How do we maintain profiles?

This is simple — properties files!
We make properties files for each environment and set the profile in the application accordingly, so it will pick the respective properties file. Don't worry, we will see how to set it up.

This article will demonstrate how to setup Profiles for your Spring Boot application.

Let's start with setting up a Spring Boot application from the Spring Starter.

 

Next, we need to import the project into your favorite IDE(I am using Intellij Idea here) as a Gradle Project. Below is the project structure:

 

In this demo application, we will see how to configure different databases at runtime based on the specific environment by their respective profiles.

As the DB connection is better to be kept in a property file, it remains external to an application and can be changed. We will do so here. But, Spring Boot — by default — provides just one property file ( application.properties). So, how will we segregate the properties based on the environment?

The solution would be to create more property files and add the "profile" name as the suffix and configure Spring Boot to pick the appropriate properties based on the profile.

Then, we need to create three  application.properties:

  1.  application-dev.properties 
  2.  application-test.properties 
  3.  application-prod.properties 

Of course, the application.properties will remain as a master properties file, but if we override any key in the profile-specific file, the latter will gain precedence.

I will now define DB configuration properties for in respective properties file and add code in DBConfiguration.class to pick the appropriate settings.

Here is the base  application.properties:

spring.profiles.active=dev

spring.application.name=Profiles
app.message=This is the primary Application Property for ${spring.application.name}

In DEV application-dev.properties, we will use an in-memory database:

#DEV ENVIRONEMNT SETTING#
app.message= This is the property file for the ${spring.application.name} specific to DEV Environment
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.url=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1
spring.datasource.username=sa
spring.datasource.password=sa

In TEST application-test.properties, we will be using a lower instance of RDS MySQL database:

#TEST ENVIRONEMNT SETTING#
app.message= This is the property file for the ${spring.application.name} specific to TEST Environment

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql-instance1.sovanmaws.us-east-1.rds.amazonaws.com:3306/profiles
spring.datasource.username=<USERNAME>
spring.datasource.password=<SECRET>

And in PROD application-prod.properties, we will use a higher instance of the MySQL database. (It's the price that matters...)

#PROD ENVIRONEMNT SETTING#
app.message= This is the property file for the ${spring.application.name} specific to PRODUCTION Environment!! Be ALERT!!

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql-instance100.sovanmaws.us-east-1.rds.amazonaws.com:3306/profiles
spring.datasource.username=<USERNAME_PROD>
spring.datasource.password=<SECRET_PASS>

Now, we are done with properties files. Let's configure in the ProfileSpecificMethods.class to pick the correct one.

package com.lkvcodestudio.profiling.configuration;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

@Configuration
@ConfigurationProperties("spring.datasource")
public class ProfileSpecificMethods {

private String driverClassName;
private String url;
private String username;
private String password;

@Profile("dev")
@Bean
public String devDatabaseConnection() {
System.out.println("DB connection for DEV - H2");
System.out.println(driverClassName);
System.out.println(url);
return "DB connection for DEV - H2";
}

@Profile("test")
@Bean
public String testDatabaseConnection() {
System.out.println("DB Connection to RDS_TEST - Low Cost Instance");
System.out.println(driverClassName);
System.out.println(url);
return "DB Connection to RDS_TEST - Low Cost Instance";
}

@Profile("prod")
@Bean
public String prodDatabaseConnection() {
System.out.println("DB Connection to RDS_PROD - High Performance Instance");
System.out.println(driverClassName);
System.out.println(url);
return "DB Connection to RDS_PROD - High Performance Instance";
}

//getters and setters
}

 

We have used the @Profile("Dev")   to let the system know that this is the BEAN  that should be picked up when we set the application profile to DEV. The other two beans will not be created at all.

One last setting is how to let the system know that this is DEV, TEST, or PROD. But, how do we do this?

We will use the application.properties to use the key below:

spring.profiles.active=dev

From here, Spring Boot will know which profile to pick. Let's run the application now!

With the profile in DEV mode, and it should pick H2 DB.