Conditional Beans in Spring

In Spring, conditional beans are beans that are created only when specific conditions are met at runtime. This allows developers to control bean registration dynamically, making applications flexible, environment-aware, and modular.

Why Conditional Beans?

Conditional beans are useful to:

• Avoid creating unnecessary beans in certain environments (dev, test, prod).
• Enable modular application configuration.
• Control bean creation based on classpath, properties, environment variables, or custom conditions.
• Support feature toggles and optional modules.

Key Annotations for Conditional Beans

Spring provides several built-in annotations to define these conditions without writing custom logic.

1. @Conditional (Custom Conditions)

• Allows developers to define a custom condition using the Condition interface.
• Spring evaluates the condition before creating the bean.

Example:

import org.springframework.context.annotation.Conditional;
import org.springframework.stereotype.Component;

@Component
@Conditional(MyCondition.class)
publicclassMyBean {
publicMyBean() {
        System.out.println("MyBean created!");
    }
}

Custom Condition:

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

publicclassMyConditionimplementsCondition {
@Override
publicbooleanmatches(ConditionContext context, AnnotatedTypeMetadata metadata) {
return"true".equals(System.getProperty("my.feature.enabled"));
    }
}

Behavior:

MyBean is created only if the system property my.feature.enabled=true.

2. @ConditionalOnProperty

Creates a bean only if a specified property exists or has a specific value.

Example:

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Component;

@Component
@ConditionalOnProperty(name = "feature.payment.enabled", havingValue = "true")
publicclassPaymentService {
publicPaymentService() {
        System.out.println("PaymentService created!");
    }
}

Behavior:

Bean is created only if feature.payment.enabled=true.

3. @ConditionalOnClass / @ConditionalOnMissingClass

• Bean creation depends on the presence or absence of a class in the classpath.
• Useful for optional dependencies or auto-configuration.

@Component
@ConditionalOnClass(name = "com.example.ExternalLibrary")
publicclassExternalIntegrationService {
// Created only if ExternalLibrary is present
}

4. @ConditionalOnBean

Bean is created only if another specific bean exists in the application context.

@Bean
@ConditionalOnBean(name = "dataSource")
public DatabaseServicedbService() {
returnnewDatabaseService();
}

5. @ConditionalOnMissingBean

Bean is created only if no other bean of the same type exists.

@Bean
@ConditionalOnMissingBean
public MyServicedefaultService() {
returnnewMyService();
}

6. @ConditionalOnExpression

Bean is created based on a Spring Expression Language (SpEL) expression.

@Bean
@ConditionalOnExpression("${feature.enabled:false} == true")
public FeatureServicefeatureService() {
returnnewFeatureService();
}

7. @ConditionalOnResource

Bean is created only if a specific resource (e.g., a file) exists on the classpath.

@Bean
@ConditionalOnResource(resources = "classpath:config/feature.properties")
public ResourceBasedServiceresourceService() {
returnnewResourceBasedService();
}

8. @ConditionalOnWebApplication / @ConditionalOnNotWebApplication

Bean is created depending on whether the application is a web application or not.

@Bean
@ConditionalOnWebApplication
public WebServicewebService() {
returnnewWebService();
}

@Bean
@ConditionalOnNotWebApplication
public ConsoleServiceconsoleService() {
returnnewConsoleService();
}

9. @Profile

Bean is created only for a specific Spring profile (dev, test, prod).

@Component
@Profile("dev")
publicclassDevDatabaseConfig {
publicDevDatabaseConfig() {
        System.out.println("Dev DB Config created!");
    }
}

• Activated with: spring.profiles.active=dev.

Advantages of Conditional Beans

• Reduces unnecessary resource usage.
• Enables environment-specific configurations.
• Supports modular and extensible applications.
• Works well with lazy initialization, creating beans only when needed.
• Makes Spring Boot auto-configuration smarter.

Best Practices

• Combine with @Lazy for delayed initialization.
• Ensure conditions are deterministic and easy to debug.
• Use property-based and profile-based conditions for environment-specific beans.
• Avoid overly complex or hard-to-read conditions.
• Use @ConditionalOnClass or @ConditionalOnMissingBean for optional dependencies and fallback implementations.

Summary:

Conditional beans allow Spring applications to adapt dynamically to runtime environments, configuration properties, available dependencies, and classpath resources. This makes applications flexible, efficient, and modular, supporting feature toggles, optional modules, and multi-environment setups