When to Use @Bean in Spring boot?

 1. Custom Bean Initialization

When a bean requires custom initialization logic that cannot be easily handled by default annotations like @Component, @Service, or @Repository, you use @Bean to explicitly define it. This allows you to set up the bean with specific configurations or initializations.

Example:

@Configuration

public class AppConfig {

     @Bean

    public MyService myService() {

        MyServiceImpl myService = new MyServiceImpl();

        myService.setSomeProperty("value");

        return myService;

    }

}

2. Third-Party Library Integration

When you need to integrate with third-party libraries or frameworks that don’t use Spring’s annotations or don’t fit well with component scanning, @Bean provides a way to register these components as Spring-managed beans.

Example:

@Configuration

public class ExternalLibraryConfig {

     @Bean

    public ThirdPartyService thirdPartyService() {

        return new ThirdPartyService("config-value");

    }

}

3. Conditional or Parameterized Bean Creation

If you need to create a bean based on certain conditions or parameters, you can use @Bean to manage this process. For example, you might want to create a bean differently based on application properties or runtime conditions.

Example:

@Configuration

public class ConditionalBeanConfig {

     @Value("${app.feature.enabled}")

    private boolean featureEnabled;

     @Bean

    public MyFeatureService myFeatureService() {

        if (featureEnabled) {

            return new AdvancedFeatureService();

        } else {

            return new BasicFeatureService();

        }

    }

}

4. Complex Bean Dependencies

When a bean has complex dependencies or requires specific configurations that are not easily managed by @Autowired or constructor injection, using @Bean allows you to explicitly control how these dependencies are wired together.

Example:

@Configuration

public class ComplexBeanConfig {

     @Bean

    public ComplexService complexService(MyDependency dependency1, AnotherDependency dependency2) {

        return new ComplexService(dependency1, dependency2);

    }

     @Bean

    public MyDependency myDependency() {

        return new MyDependency();

    }

     @Bean

    public AnotherDependency anotherDependency() {

        return new AnotherDependency();

    }

}

5. Alternative to Component Scanning

When you prefer to avoid component scanning or when component scanning is not suitable for your use case, @Bean allows you to manually register beans. This approach can be particularly useful for large projects or libraries where fine-grained control over bean configuration is necessary.

Example:

@Configuration

public class ManualBeanRegistration {

     @Bean

    public CustomComponent customComponent() {

        return new CustomComponent();

    }

}

6. Defining Bean Scopes

When you need to define specific bean scopes (e.g., singleton, prototype) or lifecycle callbacks (e.g., @PostConstruct, @PreDestroy), @Bean allows you to control these aspects explicitly.

Example:

@Configuration

public class ScopedBeanConfig {

     @Bean

    @Scope("prototype")

    public PrototypeBean prototypeBean() {

        return new PrototypeBean();

    }

}

Summary

In summary, you use @Bean in Spring Boot when you need:

• Custom Initialization: To manually configure and initialize a bean with specific setup logic.
• Third-Party Integration: To register beans from third-party libraries or frameworks.
• Conditional Creation: To create beans based on specific conditions or parameters.
• Complex Dependencies: To manage complex bean dependencies and wiring.
• Alternative to Scanning: To manually register beans rather than relying on component scanning.
• Bean Scopes and Lifecycle: To specify bean scopes and manage lifecycle callbacks.