@Bean vs @Component in Spring Boot

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides on YouTube

1. Introduction

In Spring, one of the core features is Dependency Injection (DI), which can be managed with annotations like @Bean and @Component. @Bean is used to explicitly create a Spring bean, rather than letting Spring do it automatically. It decouples the definition of the bean from the class definition. @Component is used to auto-detect and auto-configure beans using classpath scanning.

2. Key Points

1. @Bean is a method-level annotation that marks a method to create and return a bean.

2. @Component is a class-level annotation that tells Spring to treat the class as a bean.

3. @Bean is usually declared in Configuration classes methods.

4. @Component is typically used when you don't need to add any extra logic to create the bean.

3. Differences

@Bean	@Component
Used on a method to indicate that a method produces a bean to be managed by the Spring container.	Used on a class to indicate that a class is a Spring component whose lifecycle should be managed by the Spring container.
Beans created using @Bean are usually declared in configuration classes (classes annotated with @Configuration).	@Component is a class-level annotation. It is typically used for automatic detection and configuration of beans using classpath scanning.
Ideal for external libraries or classes that are not annotated with Spring annotations (e.g., third-party libraries) because it allows for explicit bean configuration.	Ideal for defining your own classes as Spring-managed components, especially when you can annotate the source code directly.
Requires manual bean definition but gives more control over bean instantiation and configuration.	Simplifies configuration by minimizing boilerplate code, relying on component scanning to discover and register beans.
Particularly useful when you need to create more complex beans that involve method calls and inter-bean dependencies.	Used for simpler scenarios where the bean does not require special configuration or initialization.

4. Example

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

@Configuration
public class AppConfig {
    @Bean
    public MyBean myBean() {
        // You can control the creation of the bean here
        return new MyBean();
    }
}

@Component
public class MyComponent {
    // Spring will automatically create a bean of type MyComponent
}

public class MyBean {
    // Bean content here
}

Output:

// No output, since this is about the configuration, not about running the application

Explanation:

1. The AppConfig class uses @Bean to create a bean of type MyBean. You can add custom creation logic in the myBean method if needed.

2. The MyComponent class is annotated with @Component, which allows Spring to automatically pick it up and create a bean instance without any additional configuration.

5. When to use?

- Use @Bean for any complex or third-party classes that you need to integrate into your Spring application, where you need to control the creation of the object.

- Use @Component for your own classes to simplify the automatic detection and configuration of your Spring beans.