What is @Component annotation in Spring? What does it do?

Hello guys, One of the main reason many people use Spring Framework is Dependency injection and auto-wiring, which means you don't need to write code to create and inject dependency, Spring will do it for you. But does it do it and how @Component annotation helps? Well, In Spring, the @Component annotation is used to mark a class as a Spring bean that should be managed by Spring's Inversion of Control (IoC) container. When a class is annotated with @Component, Spring automatically scans for such components during application startup and creates instances of these components that can be used for dependency injection. The @Component annotation is the foundation for other stereotype annotations in Spring, such as @Service, @Repository, and @Controller, which are specializations of @Component. These annotations are used to further specify the role and purpose of a component in a Spring application.

By using the @Component annotation, developers can define their own custom beans, which can be wired together and managed by the Spring container. These components can be used to encapsulate business logic, data access, or other functionalities in a Spring application, and can be easily configured and managed using Spring's IoC and dependency injection features.

Example of @Component Annotation in Spring Framework?

Now that you know what is @Component annotation and what it does, let's see an example to understand the concept better. 

Here's an example of using the @Component annotation in Spring:
public class UserService {
    // Class implementation goes here

In this example, the UserService class is annotated with @Component, which marks it as a Spring bean. This annotation tells Spring to automatically detect and create an instance of UserService as a managed bean during the application's context initialization. 

Once the bean is created, it can be injected into other parts of the application using other Spring annotations such as @Autowired or @Inject.

Dependency required for using @Component annotation in your application

In order to use the @Component annotation in Spring, you need to have the appropriate dependencies on your classpath and enable component scanning in your Spring configuration. 

Here are the steps:

1. Add the following Maven or Gradle dependencies to your project:

For Maven:


For Gradle:
implementation 'org.springframework:spring-context:5.3.10'

Note: The version number may vary depending on the version of Spring you are using or your project's requirements.

Enable component scanning in your Spring configuration. You can do this by adding the @ComponentScan annotation to one of your Spring configuration classes, or by configuring it in your application.properties or application.yml file.

Here is an example of Using @ComponentScan in a configuration class

public class AppConfig {
    // Configuration goes here

and here are example of using it on application.properties:


and on application.yml:

    base-package: com.example.package

Make sure to replace com.example.package with the package name where your @Component annotated classes are located.

With these dependencies and configuration in place, you can now use the @Component annotation in your Spring classes and have them automatically detected and managed by Spring during the application's context initialization.

What is @Component annotation in Spring? What does it do?

That's all about what is @Component annotation in Spring and what it does. In conclusion, the @Component annotation is an essential part of the Spring framework, providing a way to mark a class as a Spring bean and have it managed by the Spring container. It is a core annotation used in Spring's component scanning mechanism, which automatically detects and registers beans during the application's context initialization.

The @Component annotation is used to indicate that a class is a candidate for auto-detection as a Spring bean. By applying the @Component annotation to a class, you are instructing Spring to create an instance of that class and manage its lifecycle, allowing it to be wired into other parts of your Spring application.

The @Component annotation is a fundamental building block in Spring's inversion of control (IoC) and dependency injection (DI) features, providing a powerful and flexible way to configure and manage beans in a Spring application. 

Whether you are building a simple Spring application or a complex enterprise application, understanding and using the @Component annotation correctly is crucial for effective Spring development.

Other Java and Spring Articles, Resources and Tutorials you may like to explore

Thanks for reading this article so far. If you like my explanation of What is @Component annotation in Spring? What does it do?   then please share them with your friends and colleagues. If you have any questions or feedback, then please drop a note.

No comments:

Post a Comment

Feel free to comment, ask questions if you have any doubt.