annotations java spring spring-mvc

What’s the difference between @Component, @Repository & @Service annotations in Spring?


Can @Component, @Repository and @Service annotations be used interchangeably in Spring or do they provide any particular functionality besides acting as a notation device?

In other words, if I have a Service class and I change the annotation from @Service to @Component, will it still behave the same way?

Or does the annotation also influence the behavior and functionality of the class?


  • 14

    Being a developer with Microsoft background, I recall the semantic definition of services in the old MS SmartClientSoftwareFactory framework (now a long deprecated complex framework for distributed desktop apps). That definition (nicely documented by Rich Newman) defined the services as stateless reusable objects, preferably with singleton scope, that are used to perform business logic operations on other objects passed as arguments. I tend to view Spring services the same way

    Nov 10, 2015 at 15:56

  • 4

    Doesn’t matter!! Whatever works for you 🙂 I’ve always hated this about Spring that they always tend to define “rules” for you, which only add trivial value to your application. Not to mention Spring comes with huge stack of its own.

    – TriCore

    Jul 5, 2017 at 4:45

  • 57

    @TriCore Sprting is a framework, define “rules” for you is its job 🙂

    – Walfrat

    Sep 28, 2017 at 15:00


As many of the answers already state what these annotations are used for, we’ll here focus on some minor differences among them.

First the Similarity

First point worth highlighting again is that with respect to scan-auto-detection and dependency injection for BeanDefinition all these annotations (viz., @Component, @Service,
@Repository, @Controller) are the same. We can use one in place
of another and can still get our way around.

Differences between @Component, @Repository, @Controller and @Service


This is a general-purpose stereotype annotation indicating that the class is a spring component.

What’s special about @Component
<context:component-scan> only scans @Component and does not look for @Controller, @Service and @Repository in general. They are scanned because they themselves are annotated with @Component.

Just take a look at @Controller, @Service and @Repository annotation definitions:

public @interface Service {


public @interface Repository {


public @interface Controller {

Thus, it’s not wrong to say that @Controller, @Service and @Repository are special types of @Component annotation. <context:component-scan> picks them up and registers their following classes as beans, just as if they were annotated with @Component.

Special type annotations are also scanned, because they themselves are annotated with @Component annotation, which means they are also @Components. If we define our own custom annotation and annotate it with @Component, it will also get scanned with <context:component-scan>


This is to indicate that the class defines a data repository.

What’s special about @Repository?

In addition to pointing out, that this is an Annotation based Configuration, @Repository’s job is to catch platform specific exceptions and re-throw them as one of Spring’s unified unchecked exception. For this, we’re provided with PersistenceExceptionTranslationPostProcessor, that we are required to add in our Spring’s application context like this:

<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>

This bean post processor adds an advisor to any bean that’s annotated with @Repository so that any platform-specific exceptions are caught and then re-thrown as one of Spring’s unchecked data access exceptions.


The @Controller annotation indicates that a particular class serves the role of a controller. The @Controller annotation acts as a stereotype for the annotated class, indicating its role.

What’s special about @Controller?

We cannot switch this annotation with any other like @Service or @Repository, even though they look same.
The dispatcher scans the classes annotated with @Controller and detects methods annotated with @RequestMapping annotations within them. We can use @RequestMapping on/in only those methods whose classes are annotated with @Controller and it will NOT work with @Component, @Service, @Repository etc…

Note: If a class is already registered as a bean through any alternate method, like through @Bean or through @Component, @Service etc… annotations, then @RequestMapping can be picked if the class is also annotated with @RequestMapping annotation. But that’s a different scenario.


@Service beans hold the business logic and call methods in the repository layer.

What’s special about @Service?

Apart from the fact that it’s used to indicate, that it’s holding the business logic, there’s nothing else noticeable in this annotation; but who knows, Spring may add some additional exceptional in future.

What else?

Similar to above, in the future Spring may add special functionalities for @Service, @Controller and @Repository based on their layering conventions. Hence, it’s always a good idea to respect the convention and use it in line with layers.


  • 46

    Fantastic Explanation. You’ve cleared up a lot of my misunderstandings. Coming from a university where we built all our projects from the bottom up, I had difficulty understanding why Spring Applications just worked even though you’re not explicitly linking the program together yourself. The annotations make a lot of sense now, thank you!

    Jun 27, 2018 at 8:05


They are almost the same – all of them mean that the class is a Spring bean. @Service, @Repository and @Controller are specialized @Components. You can choose to perform specific actions with them. For example:

  • @Controller beans are used by spring-mvc
  • @Repository beans are eligible for persistence exception translation

Another thing is that you designate the components semantically to different layers.

One thing that @Component offers is that you can annotate other annotations with it, and then use them the same way as @Service.

For example recently I made:

public @interface ScheduledJob {..}

So all classes annotated with @ScheduledJob are spring beans and in addition to that are registered as quartz jobs. You just have to provide code that handles the specific annotation.


  • 24

    @Component beans are auto detectable by spring container. You don’t need to define bean in configuration file, it will be automatically detected at runtime by Spring.

    – Akash5288

    Dec 16, 2014 at 18:07