Spring: How to do AND in Profiles?

Question

Spring Profile annotation allows you to select profiles. However if you read documentation it only allows you to select more than one profile with OR operation. If you specify @Profile("A", "B") then your bean will be up if either profile A or profile B is active.

Our use case is different we want to support TEST and PROD versions of multiple configurations. Therefore sometimes we want to autowire the bean only if both profiles TEST and CONFIG1 are active.

Is there any way to do it with Spring? What would be the simplest way?

Answer 1

Since Spring 5.1 (incorporated in Spring Boot 2.1) it is possible to use a profile expression inside profile string annotation. So:

In Spring 5.1 (Spring Boot 2.1) and above it is as easy as:

@Component @Profile("TEST & CONFIG1") public class MyComponent {} 

Spring 4.x and 5.0.x:

• Approach 1: answered by @Mithun, it covers perfectly your case of converting OR into AND in your profile annotation whenever you annotate the Spring Bean also with his Condition class implementation. But I want to offer another approach that nobody proposed that has its pro's and con's.

• Approach 2: Just use @Conditional and create as many Condition implementations as combinations needed. It has the con of having to create as many implementations as combinations but if you don't have many combinations, in my opinion, it is a more concise solution and it offers more flexibility and the chance of implementing more complex logical resolutions.

The implementation of Approach 2 would be as follows.

Your Spring Bean:

@Component @Conditional(value = { TestAndConfig1Profiles.class }) public class MyComponent {} 

TestAndConfig1Profiles implementation:

public class TestAndConfig1Profiles implements Condition {     @Override     public boolean matches(final ConditionContext context, final AnnotatedTypeMetadata metadata) {         return context.getEnvironment().acceptsProfiles("TEST")                     && context.getEnvironment().acceptsProfiles("CONFIG1");     } } 

With this approach you could easily cover more complex logical situations like for example:

(TEST & CONFIG1) | (TEST & CONFIG3)

Just wanted to give an updated answer to your question and complement other answers.

Answer 2

Since Spring does not provide the AND feature out of the box. I would suggest the following strategy:

Currently @Profile annotation has a conditional annotation @Conditional(ProfileCondition.class). In ProfileCondition.class it iterates through the profiles and checks if the profile is active. Similarly you could create your own conditional implementation and restrict registering the bean. e.g.

public class MyProfileCondition implements Condition {      @Override     public boolean matches(final ConditionContext context,             final AnnotatedTypeMetadata metadata) {         if (context.getEnvironment() != null) {             final MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());             if (attrs != null) {                 for (final Object value : attrs.get("value")) {                     final String activeProfiles = context.getEnvironment().getProperty("spring.profiles.active");                      for (final String profile : (String[]) value) {                         if (!activeProfiles.contains(profile)) {                             return false;                         }                     }                 }                 return true;             }         }         return true;     }  } 

In your class:

@Component @Profile("dev") @Conditional(value = { MyProfileCondition.class }) public class DevDatasourceConfig 

NOTE: I have not checked for all the corner cases (like null, length checks etc). But, this direction could help.

Answer 3

A little bit improved version of @Mithun answer:

public class AndProfilesCondition implements Condition {

public static final String VALUE = "value";
public static final String DEFAULT_PROFILE = "default";

@Override
public boolean matches(final ConditionContext context, final AnnotatedTypeMetadata metadata) {
    if (context.getEnvironment() == null) {
        return true;
    }
    MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());
    if (attrs == null) {
        return true;
    }
    String[] activeProfiles = context.getEnvironment().getActiveProfiles();
    String[] definedProfiles = (String[]) attrs.getFirst(VALUE);
    Set<String> allowedProfiles = new HashSet<>(1);
    Set<String> restrictedProfiles = new HashSet<>(1);
    for (String nextDefinedProfile : definedProfiles) {
        if (!nextDefinedProfile.isEmpty() && nextDefinedProfile.charAt(0) == '!') {
            restrictedProfiles.add(nextDefinedProfile.substring(1, nextDefinedProfile.length()));
            continue;
        }
        allowedProfiles.add(nextDefinedProfile);
    }
    int activeAllowedCount = 0;
    for (String nextActiveProfile : activeProfiles) {
        // quick exit when default profile is active and allowed profiles is empty
        if (DEFAULT_PROFILE.equals(nextActiveProfile) && allowedProfiles.isEmpty()) {
            continue;
        }
        // quick exit when one of active profiles is restricted
        if (restrictedProfiles.contains(nextActiveProfile)) {
            return false;
        }
        // just go ahead when there is no allowed profiles (just need to check that there is no active restricted profiles)
        if (allowedProfiles.isEmpty()) {
            continue;
        }
        if (allowedProfiles.contains(nextActiveProfile)) {
            activeAllowedCount++;
        }
    }
    return activeAllowedCount == allowedProfiles.size();
}

}

Was unable to post it in the comments.