Working with Profiles in Springboot

Application configuration in Spring Boot is all about managing different settings and
behaviors that your application needs in different environments, such as development, testing,
and production. This configuration management includes setting up database URLs, cache
settings, logging levels, API keys, and more, which often vary depending on where the
application is running. Spring Boot makes this process easier by letting you define multiple
configurations in a single file (e.g., application.yml), with the ability to activate them
selectively using profiles.

Why Application Configuration Matters

1. Centralized Settings: With configuration, you control the environment’s behavior in

a central location, like application.yml.
2. Environment Flexibility: Using configuration files, you set different values for
variables across development, testing, and production environments.
3. Easier Maintenance: Centralized configuration makes it easy to update and maintain
settings across multiple environments.
4. Security: Sensitive values, like API keys and database credentials, can be managed in
an external configuration or environment-specific files.

What You’ll Learn About Application Configuration

When you dive into application configuration, you’ll learn how to:

• Use application.yml and application.properties files.

• Work with environment-specific configuration values.
• Define configuration properties with Spring’s @Value and
@ConfigurationProperties annotations.
• Securely manage sensitive data outside of the codebase.

The Need for Profiles in Spring Boot

Profiles let you define different configurations for different environments within the same
application. With Spring Boot profiles, you set up multiple configurations that automatically
adjust based on the profile you activate.

Why Profiles Are Essential

1. Environment-Specific Configuration: Profiles allow each environment to have its

own configuration without impacting other environments.
2. Efficient Testing: Testing requires different settings, such as a different database or
specific test services, without overwriting production data.
3. Simple Deployment: Profiles help streamline deployment by switching to the correct
configuration without manually adjusting files or code.

Abilash Shankarpalli
 4. Flexible Behavior Management: You can use profiles to control which beans,
services, or configurations to load, making your app adaptable.

What You’ll Learn About Profiles

In working with profiles, you’ll cover:

• Setting Up Profiles in application.yml: Learn to define multiple profiles and

activate them selectively based on the environment.
• Activating Profiles: You’ll activate profiles through Gradle tasks, environment
variables, or directly within the IDE.
• Profile-Specific Beans: With the @Profile annotation, you’ll control which beans
are loaded based on the active profile.
• External Configurations: Manage profile configurations externally for sensitive
environments, especially useful in production.

1. Basic Setup: Spring Boot Profiles with application.yml and Gradle

1. Create application.yml: Define profiles directly within application.yml, like we

did before, so configurations for different environments are separated.
2. Define Profile-Specific Configurations: Here’s an example with profiles for dev,
test, and prod environments in application.yml.

# application.yml
# Default configuration
spring:
datasource:
url: jdbc:h2:mem:defaultdb
driver-class-name: org.h2.Driver
username: default_user
password: default_pass
application:
name: MyApp

# Development configuration
---
spring:
config:
activate:
on-profile: dev
datasource:
url: jdbc:mysql://localhost:3306/dev_db
driver-class-name: com.mysql.cj.jdbc.Driver
username: dev_user
password: dev_pass
application:
name: MyApp (Development)

# Production configuration
---
spring:
config:
activate:
on-profile: prod
datasource:

Abilash Shankarpalli
 url: jdbc:mysql://localhost:3306/prod_db
driver-class-name: com.mysql.cj.jdbc.Driver
username: prod_user
password: prod_pass
application:
name: MyApp (Production)

3. Set Up Profile-Specific Beans: Use @Profile annotations to define beans specific to

each environment.

@Configuration
public class DataSourceConfig {

@Bean
@Profile("dev")
public DataSource devDataSource() {
return DataSourceBuilder.create()
.url("jdbc:mysql://localhost:3306/dev_db")
.username("dev_user")
.password("dev_pass")
.build();
}

@Bean
@Profile("prod")
public DataSource prodDataSource() {
return DataSourceBuilder.create()
.url("jdbc:mysql://localhost:3306/prod_db")
.username("prod_user")
.password("prod_pass")
.build();
}
}

2. Running Profiles with Gradle

Gradle allows you to activate profiles by passing arguments or by specifying them within the
Gradle tasks.

Method 1: Command-Line Arguments

To specify a profile when you run the application, you can pass it as a command-line
argument to Gradle:

# Run the development profile

./gradlew bootRun -Dspring.profiles.active=dev

# Run the production profile

./gradlew bootRun -Dspring.profiles.active=prod

This command activates the specified profile, and Spring Boot will load the corresponding
properties from application.yml.

Method 2: Configure Gradle Task for Specific Profile

Abilash Shankarpalli
You can define custom Gradle tasks that set profiles automatically. For instance:

// build.gradle

tasks.register("bootRunDev",
org.springframework.boot.gradle.tasks.run.BootRun) {
group = "application"
description = "Run the application with the dev profile"
args = ["--spring.profiles.active=dev"]
}

tasks.register("bootRunProd",
org.springframework.boot.gradle.tasks.run.BootRun) {
group = "application"
description = "Run the application with the prod profile"
args = ["--spring.profiles.active=prod"]
}

Then, you can run these tasks:

# Run the development profile task

./gradlew bootRunDev

# Run the production profile task

./gradlew bootRunProd

3. Managing Profile-Specific Properties Using @Value and

@ConfigurationProperties

Using @Value

If you want to inject specific properties from a profile, you can use the @Value annotation:

@Component
public class ApplicationProperties {

@Value("${spring.datasource.url}")
private String dataSourceUrl;

@Value("${spring.datasource.username}")
private String username;

public void printProperties() {

System.out.println("DataSource URL: " + dataSourceUrl);
System.out.println("Username: " + username);
}
}

Using @ConfigurationProperties

To handle a group of properties, @ConfigurationProperties is convenient and keeps

properties grouped logically.

@Component

Abilash Shankarpalli
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties {

private String url;

private String username;
private String password;

// Getters and setters

}

In your YAML file, define properties like this:

spring:
datasource:
url: jdbc:mysql://localhost:3306/dev_db
username: dev_user
password: dev_pass

4. Profile-Specific Example Services

Here are a few examples of how to make services or components profile-specific.

Example: Email Service Based on Environment

public interface EmailService {

void sendEmail(String to, String message);
}

@Service
@Profile("dev")
public class DevEmailService implements EmailService {
@Override
public void sendEmail(String to, String message) {
System.out.println("Sending email in development mode to " + to);
}
}

@Service
@Profile("prod")
public class ProdEmailService implements EmailService {
@Override
public void sendEmail(String to, String message) {
// Actual production email service code
}
}

This setup will use DevEmailService when the development profile is active, and
ProdEmailService for production, allowing different behavior based on the environment.

5. Testing Profiles Using @ActiveProfiles in Spring Tests

When testing, you can specify which profile should be active using @ActiveProfiles:

Abilash Shankarpalli
@SpringBootTest
@ActiveProfiles("test")
public class MyServiceTest {

@Autowired
private DataSource dataSource;

@Test
public void testDataSource() {

System.out.println(dataSource.getConnection().getMetaData().getURL());
// Expected to use the test profile datasource URL
}
}

This is useful to isolate configurations during testing, making sure the actual production or
development configurations are not affected.

6. Externalizing Profile Configuration for Security

For production deployments, sensitive configuration data (e.g., database passwords) can be
managed externally instead of within application.yml.

# Run with external properties

./gradlew bootRun -Dspring.config.location=/path/to/external/application-
prod.yml -Dspring.profiles.active=prod

By pointing Spring Boot to an external configuration file, you keep sensitive information
separate from your codebase.

7. Best Practices for Managing Profiles with Gradle and Spring Boot

1. Organize Profile-Specific Configurations Clearly: Use YAML and group

properties for better readability and maintenance.
2. Automate Profile Selection with Gradle: Custom tasks in build.gradle simplify
running the application in different environments.
3. Secure Sensitive Data: Keep sensitive data like database passwords in external files
or as environment variables.
4. Test Profiles Thoroughly: Ensure each profile works as expected and doesn’t affect
others.

Abilash Shankarpalli
Feel free to reach out or mail me at
[email protected], for help with
Interview preparation or resume reviews.

Do follow Abilash Shankarpalli for more

such posts

Happy Learning!

Abilash Shankarpalli