How to Restrict a Spring Bean from Auto Configuration ?

In Spring, you can control or restrict autowiring for specific classes in several ways, preventing Spring from automatically injecting certain beans. Here are different approaches to achieve this:

1. Use @Primary to Avoid Conflicts

If you have multiple beans of the same type and you want to prevent autowiring conflicts, but still want one specific bean to be injected by default, you can use the @Primary annotation on the preferred bean. This prevents Spring from trying to autowire other beans of the same type by default.

Example:

@Configuration
public class AppConfig {

    @Bean
    @Primary  // This bean will be autowired by default
    public MyService myPrimaryService() {
        return new MyServiceImpl1();
    }

    @Bean
    public MyService mySecondaryService() {
        return new MyServiceImpl2();
    }
}

This ensures that the myPrimaryService bean is injected by default and the mySecondaryService bean won’t be autowired unless explicitly specified.

2. Use @Qualifier to Select Specific Beans

You can use the @Qualifier annotation to specifically choose which bean to autowire when you have multiple candidates. This way, Spring will not inject other beans unless the @Qualifier is specified.

Example:

@Component
public class MyComponent {

    private MyService myService;

    // Only the bean named "mySecondaryService" will be autowired
    @Autowired
    public MyComponent(@Qualifier("mySecondaryService") MyService myService) {
        this.myService = myService;
    }
}

Here, only the mySecondaryService bean is injected. The other bean (like myPrimaryService) will not be autowired.

3. Use @Lazy to Delay Bean Initialization

If you want to ensure that a specific class is not automatically initialized and injected into other beans unless explicitly required, you can mark that bean with the @Lazy annotation. This defers the initialization and autowiring until the bean is actually needed.

Example:

@Component
@Lazy
public class LazyService {
    public LazyService() {
        System.out.println("LazyService initialized!");
    }
}

In this example, the LazyService bean will only be created when it’s explicitly requested, preventing it from being eagerly autowired into other components.

4. Use @Autowired(required = false)

You can use @Autowired(required = false) to make autowiring optional for specific beans. If Spring finds no matching beans, it won’t throw an exception, and the class won’t be autowired.

Example:

@Component
public class MyComponent {

    // Will not autowire if there is no bean available
    @Autowired(required = false)
    private MyService optionalService;
}

In this case, Spring will not fail or inject anything if MyService is not found. This can be used to restrict autowiring if the bean doesn’t exist in certain profiles or configurations.

5. Use @ComponentScan(excludeFilters) to Exclude Specific Classes from Component Scanning

If you don’t want Spring to consider certain classes for autowiring or bean creation at all, you can exclude them from component scanning.

Example:

@SpringBootApplication
@ComponentScan(
    excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = { MyService.class })
)
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

In this example, the MyService class is excluded from component scanning, and it won’t be autowired anywhere in the application.

6. Use @Profile to Restrict Beans to Specific Profiles

You can use @Profile to restrict certain beans to only be autowired when a specific profile is active. Beans not defined in the active profile will not be available for autowiring.

Example:

@Configuration
@Profile("dev")
public class DevServiceConfig {

    @Bean
    public MyService devService() {
        return new DevService();
    }
}

@Configuration
@Profile("prod")
public class ProdServiceConfig {

    @Bean
    public MyService prodService() {
        return new ProdService();
    }
}

Here, DevService will only be autowired when the dev profile is active, and ProdService will only be autowired when the prod profile is active.

7. Use @Conditional to Conditionally Load Beans

You can use the @Conditional annotation to load specific beans based on custom conditions, effectively restricting which beans are available for autowiring under certain conditions.

Example:

@Configuration
public class AppConfig {

    @Bean
    @Conditional(MyCondition.class)  // Load this bean only if MyCondition is satisfied
    public MyService myConditionalService() {
        return new MyServiceImpl();
    }
}

This bean will only be autowired if the condition specified in MyCondition is met. You can create custom conditions by implementing Condition.

In Spring Boot, the Condition class is part of the conditional bean registration mechanism, which allows you to control the creation of beans based on certain conditions. It is used along with the @Conditional annotation to apply custom logic that determines whether a specific bean should be registered in the Spring context.

To implement a condition, you need to create a class that implements the org.springframework.context.annotation.Condition interface. The Condition interface provides a matches() method where the custom logic is written to decide whether the condition is met or not. If the condition is met, the bean or configuration will be included in the Spring context; otherwise, it will be excluded.

Steps to Use a Custom Condition:

1. Implement the Condition Interface.
2. Create a Bean or Configuration with @Conditional.
3. Use Conditional Beans in your Spring Boot Application.

Example of Creating a Custom Condition:

1. Implement a Condition Class

You need to implement the Condition interface and override the matches() method, which contains the logic to determine whether a bean should be created.

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

public class MyCustomCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // Custom logic to check the condition
        String myProperty = context.getEnvironment().getProperty("my.custom.property");

        // Return true if condition is satisfied, otherwise false
        return "true".equals(myProperty);
    }
}

In this example, the MyCustomCondition class checks if the my.custom.property in the application’s environment is set to "true". If it is, the bean or configuration will be loaded.

2. Use @Conditional to Apply the Condition to a Bean

Once the Condition class is defined, you can use it to conditionally load beans or configurations by applying the @Conditional annotation.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Conditional;

@Configuration
public class MyConfig {

    @Bean
    @Conditional(MyCustomCondition.class)  // Apply the custom condition here
    public MyService myService() {
        return new MyServiceImpl();
    }
}

In this example, the MyService bean will only be created if the condition in MyCustomCondition is met (i.e., my.custom.property is set to "true").

3. Set the Condition in application.properties

You can define the property that the condition depends on in your application.properties or application.yml file.

my.custom.property=true

If the my.custom.property is set to "true", the MyService bean will be loaded. Otherwise, it will be excluded.

Real-World Example: Conditional on a Property

Let’s create a more practical example where we only want to register a service if a certain property is set.

1. Create the Condition Class

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

public class OnFeatureEnabledCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // Check if a specific property is set to 'true'
        String featureEnabled = context.getEnvironment().getProperty("featureX.enabled");
        return "true".equalsIgnoreCase(featureEnabled);
    }
}

2. Create a Configuration Class and Use the Condition

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Conditional;

@Configuration
public class FeatureXConfig {

    @Bean
    @Conditional(OnFeatureEnabledCondition.class)  // Apply the custom condition
    public FeatureXService featureXService() {
        return new FeatureXService();
    }
}

3. Define the Property in application.properties

featureX.enabled=true

If featureX.enabled is set to true, the FeatureXService bean will be created; otherwise, it won’t be available in the Spring context.

Other Common Conditional Annotations

Spring Boot also provides several built-in conditional annotations to register beans or configurations based on common conditions:

1. @ConditionalOnProperty: Registers the bean only if a specific property exists or matches a certain value.

   @ConditionalOnProperty(name = "my.feature.enabled", havingValue = "true")

2. @ConditionalOnClass: Registers the bean only if a specific class is present on the classpath.

   @ConditionalOnClass(name = "com.example.MyClass")

3. @ConditionalOnMissingBean: Registers the bean only if no other bean of the same type exists.

   @ConditionalOnMissingBean(MyService.class)

4. @ConditionalOnBean: Registers the bean only if another specified bean exists in the context.

   @ConditionalOnBean(MyOtherService.class)

Use Cases for @Conditional and Condition Class:

• Feature Toggles: Enable or disable certain features based on configuration properties.
• Environment-Specific Beans: Load beans only in certain environments like dev, test, or prod.
• Conditional on Classpath: Only load beans if specific dependencies or classes are available.
• Conditional on Runtime Properties: Load beans based on system properties, environment variables, or other runtime factors.

Summary:

• Condition: Custom class implementing Condition interface with custom logic in the matches() method.
• @Conditional: Used on beans or configurations to make their registration dependent on the custom condition.
• Practical Use: Helps in creating flexible, environment-aware applications with optional features, classes, or services.

By using conditions, you can significantly enhance the flexibility and modularity of your Spring Boot application, making it easier to adapt to different environments or configurations.

8. Use @Primary and @Qualifier Together

To avoid unintended autowiring, you can combine @Primary and @Qualifier so that only the desired bean is injected, and others are restricted.

Example:

@Configuration
public class AppConfig {

    @Bean
    @Primary
    public MyService primaryService() {
        return new MyPrimaryService();
    }

    @Bean
    public MyService secondaryService() {
        return new MySecondaryService();
    }
}

@Component
public class MyComponent {

    private final MyService myService;

    @Autowired
    public MyComponent(@Qualifier("secondaryService") MyService myService) {
        this.myService = myService;
    }
}

In this case, even though primaryService is marked as @Primary, only secondaryService is autowired due to the use of @Qualifier.

Conclusion:

There are multiple ways to restrict autowiring in Spring Boot depending on your requirements:

1. Use @Primary: Ensure one bean is the default for autowiring.
2. Use @Qualifier: Specify exactly which bean to autowire.
3. Use @Lazy: Defer initialization and avoid eager autowiring.
4. Use @Autowired(required = false): Make autowiring optional for specific beans.
5. Use @ComponentScan(excludeFilters): Exclude certain classes from being autowired by excluding them from scanning.
6. Use @Profile: Restrict beans to specific active profiles.
7. Use @Conditional: Conditionally load and autowire beans based on specific conditions.
8. Use @Primary and @Qualifier Together: Combine them to ensure only the desired bean is autowired.

These methods allow you to fine-tune Spring Boot’s autowiring behavior based on the context of your application.