Скачать или смотреть How to Choose Property Source in Spring by Combining Profiles

Learn how to effectively combine Spring profiles to choose property sources for different environments, including mock configurations with ease and maintainability.
---
This video is based on the question https://stackoverflow.com/q/63776052/ asked by the user 'Nikolas Charalambidis' ( https://stackoverflow.com/u/3764965/ ) and on the answer https://stackoverflow.com/a/63777225/ provided by the user 'mikhail.sharashin' ( https://stackoverflow.com/u/14224567/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Spring choose property source by a combination of profiles

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
How to Choose Property Source in Spring by Combining Profiles

Spring Boot makes it remarkably easy to manage properties for various environments using profiles. However, when your needs become more complex—such as handling both the environment name and additional profiles like mocks—the challenge can become quite daunting. In this post, we'll explore a clean and efficient way to manage these property sources using Spring's capabilities.

The Problem: Environment-Specific Configurations

Imagine you are working on a Spring Boot application with multiple environments, such as integration (int) and development (dev). You maintain separate configuration files—application-int.yml and application-dev.yml—that specify similar properties for web services. Each file holds values for endpoints and mock endpoints, as shown below:

application-int.yml

[[See Video to Reveal this Text or Code Snippet]]

application-dev.yml

[[See Video to Reveal this Text or Code Snippet]]

Your goal is to select the appropriate property based on both the environment and the active profile, which can lead to a complex hierarchy in configuration classes if not addressed correctly. For instance, you need to process:

ws.endpoint for dev profiles

ws.endpoint for int profiles

ws.mock for dev mock profiles

ws.mock for int mock profiles

In addition, you are keen on keeping the solution readable and maintainable.

The Solution: Constructor Injection with Environment

To address this challenge effectively, we can utilize Spring's Environment bean and set the property in the constructor of your configuration class. This solution, while not the most elegant, is straightforward and effective.

Here’s a breakdown of the implementation:

Step 1: Inject the Environment

By injecting the Environment bean into your configuration class, you gain access to profile-related data.

Step 2: Determine Active Profiles

Use the getActiveProfiles() method from the Environment bean to check if the mock profile is active.

Step 3: Set the Property Value

Based on the outcome from the previous step, set the wsUrl variable accordingly with the correct property from the available profiles.

Example Implementation

Below is a sample implementation based on the above steps:

[[See Video to Reveal this Text or Code Snippet]]

Explanation of the Code

Constructor Injection: Our configuration class receives the Environment instance through its constructor.

Profile Check: The Arrays.asList(environment.getActiveProfiles()).contains("mock") line checks if the mock profile is included in the active profiles.

Property Resolution: Based on the profile check, the appropriate property—either ws.mock or ws.endpoint—is assigned to wsUrl.

Why This Approach?

Simplicity: By using constructor injection and property resolution based on active profiles, we avoid convoluted configurations and maintain readability.

Maintainable Structure: Keeping both variables in a common property file simplifies managing and updating configurations over time.

Conclusion

Managing multiple profiles with specific needs can be challenging, especially when additional complexity—such as mocking—comes into play. The outlined method of utilizing Spring’s Environment bean with constructor injection offers a viable solution that maintains readability and improves maintainability. By structuring your configurations this way, you can effectively handle environment-specific properties without cluttering your codebase.

Now that you have a clear pathway to resolving property source selection based on environment and active profiles, it's time to implement this solution into your own projects and simplify your configurations for futur