Spring – Stereotype annotations
In spring autowiring, @Autowired
annotation handles only wiring part. We still have to define the beans so the container is aware of them and can inject them for us.
With @Component
, @Repository
, @Service
and @Controller
annotations in place and automatic component scanning enabled, Spring will automatically import the beans into the container and inject to dependencies. These annotations are called Stereotype annotations as well.
Before jumping to example use of these annotations, let’s learn quick facts about these annotations which will help us in making a better decision about when to use which annotation.
1. Spring bean stereotype annotations
1.1. @Component annotation
The @Component
annotation marks a java class as a bean so the component-scanning mechanism of spring can pick it up and pull it into the application context. To use this annotation, apply it over class as below:
@Component public class EmployeeDAOImpl implements EmployeeDAO { ... }
1.2. @Repository annotation
Although above use of @Component
is good enough but we can use more suitable annotation that provides additional benefits specifically for DAOs i.e. @Repository
annotation. The @Repository
annotation is a specialization of the @Component
annotation with similar use and functionality. In addition to importing the DAOs into the DI container, it also makes the unchecked exceptions (thrown from DAO methods) eligible for translation into Spring DataAccessException
.
1.3. @Service annotation
The @Service
annotation is also a specialization of the component annotation. It doesn’t currently provide any additional behavior over the @Component
annotation, but it’s a good idea to use @Service
over @Component
in service-layer classes because it specifies intent better. Additionally, tool support and additional behavior might rely on it in the future.
1.4. @Controller annotation
@Controller
annotation marks a class as a Spring Web MVC controller. It too is a @Component
specialization, so beans marked with it are automatically imported into the DI container. When we add the @Controller
annotation to a class, we can use another annotation i.e. @RequestMapping
to map URLs to instance methods of a class.
2. Using @Component, @Repository, @Service and @Controller annotations
As I already said that you use @Repository
, @Service
and @Controller
annotations over DAO, manager and controller classes. But in real life, at DAO and manager layer we often have separate classes and interfaces. Interface for defining the contract, and classes for defining the implementations of contracts.
Where to use these annotations? Let’s find out.
public interface EmployeeDAO { //... } @Repository public class EmployeeDAOImpl implements EmployeeDAO { //... }
Once you have these stereotype annotations on beans, you can directly use bean references defined inside concrete classes. Note the references are of type interfaces. Spring DI container is smart enough to inject the correct instance in this case.
3. Difference between @Component and @Bean annotations
In Spring, both annotations are quite different.
@Component
used to auto-detect and auto-configure beans using classpath scanning. There’s an implicit one-to-one mapping between the annotated class and the bean (i.e. one bean per class).
@Bean
is used to explicitly declare a single bean, rather than letting Spring do it automatically for us.
Another big difference is that @Component
is a class level annotation where as @Bean
is a method level annotation and ,by default, name of the method serves as the bean name.
You must log in to post a comment.