Environment-based profiles in Spring Boot

Introduction

Environment-based profiles help your application use different settings for different places, like your computer or a live server. This keeps things organized and safe.

You want to use a test database on your computer but a real database on the live server.

You need to turn on extra logging only when debugging locally.

You want to use different email services for development and production.

You want to enable or disable features depending on where the app runs.

You want to keep secret keys safe by not putting them in the main code.

Syntax

Spring Boot

spring.profiles.active=profileName

# In application-profileName.properties or application-profileName.yml
property.key=value

Profiles are named sets of configuration you can switch between.

You activate a profile by setting spring.profiles.active in your main config or environment.

Examples

This example shows two profiles: dev and prod. The app uses port 8081 in dev and port 80 in prod.

Spring Boot

# application.properties
spring.profiles.active=dev

# application-dev.properties
server.port=8081

# application-prod.properties
server.port=80

Using YAML format, the test profile sets logging to debug level.

Spring Boot

# application.yml
spring:
  profiles:
    active: test

# application-test.yml
logging:
  level:
    root: DEBUG

You can also choose the profile when starting the app from the command line.

Spring Boot

# Activate profile via command line
java -jar app.jar --spring.profiles.active=prod

Sample Program

This Spring Boot app has two beans. One runs only if the dev profile is active, the other only if prod is active. When you run the app with --spring.profiles.active=dev, it prints the dev message. With prod, it prints the prod message.

Spring Boot

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

@Component
@Profile("dev")
class DevBean {
    public DevBean() {
        System.out.println("Dev profile active: Using development settings.");
    }
}

@Component
@Profile("prod")
class ProdBean {
    public ProdBean() {
        System.out.println("Prod profile active: Using production settings.");
    }
}

Important Notes

You can have multiple profiles active at once by separating them with commas.

Use profiles to keep secrets and environment differences out of your main code.

Check which profile is active by printing or logging spring.profiles.active.

Summary

Profiles let your app use different settings for different environments.

Activate profiles in config files or command line.

Use @Profile to run code only for certain profiles.

Practice

1.

What is the main purpose of using profiles in a Spring Boot application?

easy

A. To separate configuration for different environments like development and production

B. To speed up the application startup time

C. To enable multi-threading in the application

D. To automatically generate database schemas

Solution

1. Step 1: Understand what profiles do

   Profiles allow you to define different settings for different environments, such as development, testing, or production.

2. Step 2: Match purpose with options

   Only To separate configuration for different environments like development and production describes separating configuration for different environments, which is the main use of profiles.

3. Final Answer:

   To separate configuration for different environments like development and production -> Option A

4. Quick Check:

   Profiles = environment-specific settings [OK]

Hint: Profiles separate configs by environment, like dev vs prod [OK]

Common Mistakes:

• Thinking profiles speed up startup
• Confusing profiles with threading
• Assuming profiles auto-generate schemas

2.

Which of the following is the correct way to activate a profile named dev in application.properties?

easy

A. profiles.active=dev

B. spring.profiles.active=dev

C. spring.active.profile=dev

D. spring.profile=dev

Solution

1. Step 1: Recall the correct property key

   The correct property to activate profiles is spring.profiles.active.

2. Step 2: Compare options

   Only spring.profiles.active=dev uses the exact correct key and value format.

3. Final Answer:

   spring.profiles.active=dev -> Option B

4. Quick Check:

   Activate profile with spring.profiles.active [OK]

Hint: Use spring.profiles.active to set active profile [OK]

Common Mistakes:

• Using spring.active.profile instead
• Omitting 'spring' prefix
• Using singular 'profile' instead of 'profiles'

3.

Given the following Spring Boot code snippet, what will be printed if the active profile is prod?

@Component
@Profile("dev")
public class DevService {
    public DevService() {
        System.out.println("DevService active");
    }
}

@Component
@Profile("prod")
public class ProdService {
    public ProdService() {
        System.out.println("ProdService active");
    }
}

medium

A. ProdService active

B. DevService active

C. Both DevService active and ProdService active

D. No output printed

Solution

1. Step 1: Identify active profile

   The active profile is prod, so only beans with @Profile("prod") will be created.

2. Step 2: Determine which constructor runs

   Only ProdService constructor runs, printing "ProdService active".

3. Final Answer:

   ProdService active -> Option A

4. Quick Check:

   @Profile("prod") runs only with prod profile [OK]

Hint: Only beans matching active profile run constructors [OK]

Common Mistakes:

• Assuming both beans run regardless of profile
• Confusing dev and prod profiles
• Thinking no output prints if profile mismatches

4.

Consider this Spring Boot configuration snippet in application.properties:

spring.profiles.active=dev,prod

What is the problem with this configuration?

medium

A. Multiple profiles can be active simultaneously, so no problem

B. Profiles should be separated by semicolon, not comma

C. Activating both dev and prod profiles together can cause conflicts

D. spring.profiles.active cannot be set in application.properties

Solution

1. Step 1: Understand multiple active profiles

   Spring Boot allows multiple profiles active at once, but dev and prod usually have conflicting settings.

2. Step 2: Identify the issue

   Activating both dev and prod together can cause unexpected behavior or conflicts in configuration.

3. Final Answer:

   Activating both dev and prod profiles together can cause conflicts -> Option C

4. Quick Check:

   Dev and prod active together causes config conflicts [OK]

Hint: Avoid activating dev and prod profiles simultaneously [OK]

Common Mistakes:

• Thinking comma separator is invalid
• Believing multiple profiles never cause issues
• Assuming spring.profiles.active can't be set in properties

5.

You want to create a bean that only loads when test profile is active and another bean that loads for all profiles except test. Which annotation setup is correct?

hard

A. @Profile("test") on first bean, no annotation on second bean

B. No need for @Profile, beans load automatically

C. @Profile("test") on first bean, @Profile("prod") on second bean

D. @Profile("test") on first bean, @Profile("!test") on second bean

Solution

1. Step 1: Use @Profile("test") for test-only bean

   This ensures the first bean loads only when the test profile is active.

2. Step 2: Use @Profile("!test") for all except test

   The negation !test means the second bean loads when test is not active.

3. Final Answer:

   @Profile("test") on first bean, @Profile("!test") on second bean -> Option D

4. Quick Check:

   Use @Profile("!profile") to exclude a profile [OK]

Hint: Use @Profile("!test") to exclude test profile [OK]

Common Mistakes:

• Not using @Profile on second bean causes it to always load
• Using @Profile("prod") limits second bean to prod only
• Assuming beans load automatically without profiles