¿Cuál es la diferencia entre las anotaciones de @Component, @Repository y @Service en Spring?

¿Las @Component , @Repository y @Service pueden usar indistintamente en Spring o proporcionan alguna funcionalidad particular además de actuar como un dispositivo de notación?

En otras palabras, si tengo una clase de servicio y cambio la anotación de @Service a @Component , ¿seguirá comportándose de la misma manera?

¿O la anotación también influye en el comportamiento y la funcionalidad de la clase?

De la documentación de spring :

En Spring 2.0 y posteriores, la anotación @Repository es un marcador para cualquier clase que cumpla la función o estereotipo (también conocido como Data Access Object o DAO) de un repository. Entre los usos de este marcador está la traducción automática de excepciones.

Spring 2.5 introduce más anotaciones de estereotipo: @Component , @Service y @Controller . @Component es un estereotipo genérico para cualquier componente gestionado por Spring. @Repository , @Service y @Controller son especializaciones de @Component para casos de uso más específicos, por ejemplo, en las capas de persistencia, servicio y presentación, respectivamente.

Por lo tanto, puede anotar sus clases de componentes con @Component , pero al @Repository con @Repository , @Service o @Controller , sus clases son más adecuadas para el procesamiento por herramientas o la asociación con aspectos. Por ejemplo, estas anotaciones de estereotipo son objectives ideales para los puntos de corte.

Por lo tanto, si elige entre usar @Component o @Service para su capa de servicio, @Service es claramente la mejor opción. Del mismo modo, como se indicó anteriormente, @Repository ya es compatible como un marcador para la traducción automática de excepciones en su capa de persistencia.

 ┌────────────┬─────────────────────────────────────────────────────┐ │ Annotation │ Meaning │ ├────────────┼─────────────────────────────────────────────────────┤ │ @Component │ generic stereotype for any Spring-managed component │ │ @Repository│ stereotype for persistence layer │ │ @Service │ stereotype for service layer │ │ @Controller│ stereotype for presentation layer (spring-mvc) │ └────────────┴─────────────────────────────────────────────────────┘ 

Como muchas de las respuestas ya indican para qué se usan estas anotaciones, aquí nos centraremos en algunas pequeñas diferencias entre ellas.

Primero la similitud

El primer punto que vale la pena resaltar nuevamente es que con respecto a la detección automática de escaneo y la dependency injection para BeanDefinition, todas estas anotaciones (viz., @Component, @Service, @Repository, @Controller) son las mismas. Podemos usar uno en lugar de otro y todavía podemos seguir nuestro camino.


Diferencias entre @Component, @Repository, @Controller y @Service

@Componente

Esta es una anotación de estereotipo de propósito general que indica que la clase es un componente de spring.

Qué tiene de especial @Component
solo escanea @Component y no busca @Controller , @Service y @Repository en general. Se escanean porque están anotados con @Component .

Solo eche un vistazo a las definiciones de anotaciones @Controller , @Service y @Repository :

 @Component public @interface Service { …. } 

 @Component public @interface Repository { …. } 

 @Component public @interface Controller { … } 

Por lo tanto, no está mal decir que @Controller , @Service y @Repository son tipos especiales de anotación @Component . los levanta y registra sus siguientes clases como beans, como si estuvieran anotados con @Component .

Se escanean porque están anotados con la anotación @Component . Si definimos nuestra propia anotación personalizada y la anotamos con @Component , también se escaneará con


@Repositorio

Esto es para indicar que la clase define un depósito de datos.

¿Qué tiene de especial el @Repository?

Además de señalar que se trata de una configuración basada en anotaciones , el trabajo de @Repository es atrapar excepciones específicas de la plataforma y volver a lanzarlas como una de las excepciones sin marcar unificadas de Spring. Y para esto, se nos proporciona PersistenceExceptionTranslationPostProcessor , que debemos agregar en el contexto de aplicación de Spring de esta manera:

  

Este postprocesador de frijoles agrega un asesor a cualquier bean que está anotado con @Repository para que cualquier excepción específica de la plataforma sea capturada y luego retomada como una de las excepciones de acceso a datos sin marcar de Spring.


@Controlador

La anotación @Controller indica que una clase en particular cumple la función de un controlador. La anotación @Controller actúa como un estereotipo para la clase anotada, lo que indica su función.

¿Qué tiene de especial @Controller?

No podemos cambiar esta anotación por ninguna otra como @Service o @Repository , aunque tengan el mismo aspecto. El despachador escanea las clases anotadas con @Controller y detecta las anotaciones @RequestMapping dentro de ellas. Solo podemos usar @RequestMapping en @Controller clases anotadas.


@Servicio

@Services mantiene la lógica comercial y el método de llamada en la capa de repository.

¿Qué tiene de especial @Service?

Además del hecho de que se usa para indicar que mantiene la lógica comercial, no hay una especialidad notable que proporcione esta anotación, pero quién sabe si la spring puede agregar alguna excepción adicional en el futuro.


¿Qué más?

Similar a lo anterior, en el futuro Spring puede optar por agregar funcionalidades especiales para @Service , @Controller y @Repository función de sus convenciones de estratificación. Por lo tanto, siempre es una buena idea respetar la convención y usarlos en línea con las capas.

Son casi lo mismo, todos ellos significan que la clase es un Spring Bean. @Service , @Repository y @Controller son @Component especializados de @Component . Puede elegir realizar acciones específicas con ellos. Por ejemplo:

  • @Controller beans @Controller son utilizados por spring-mvc
  • @Repository beans @Repository son elegibles para la traducción de excepción de persistencia

Otra cosa es que designes semánticamente los componentes a diferentes capas.

Una cosa que @Component ofrece es que puede anotar otras anotaciones con ella, y luego usarlas de la misma manera que @Service .

Por ejemplo, recientemente hice:

 @Component @Scope("prototype") public @interface ScheduledJob {..} 

Por lo tanto, todas las clases anotadas con @ScheduledJob son beans de spring y, además de eso, están registradas como trabajos de cuarzo. Solo debe proporcionar un código que maneje la anotación específica.

@Component es equivalente a

  

@Service, @Controller, @Repository = {@Component + algunas funciones más especiales}

Eso significa que Service, The Controller y Repository son funcionalmente iguales.

Las tres anotaciones se usan para separar “Capas” en su aplicación,

  • Los controladores simplemente hacen cosas como despachar, reenviar, llamar a métodos de servicio, etc.
  • Service Hold business Logic, Cálculos, etc.
  • Los repositorys son los DAO (Objetos de acceso a datos) y acceden directamente a la base de datos.

Ahora puedes preguntar por qué separarlos: (Supongo que conoces la progtwigción orientada a aspectos de AOP)

Digamos que desea monitorear la actividad de la capa DAO solamente. Escribirá una clase Aspect (Clase A) que realice un registro antes y después de que se invoque cada método de su DAO, puede hacerlo utilizando AOP ya que tiene tres capas distintas y no está mezclado.

Entonces puede hacer el registro de DAO “alrededor”, “antes” o “después” de los métodos DAO. Usted podría hacer eso porque tenía un DAO en primer lugar. Lo que acaba de lograr es la separación de preocupaciones o tareas.

Imagínese si hubiera solo una anotación @Controller, entonces este componente tendrá despachador, lógica de negocios y base de datos de acceso, todo mezclado, ¡código tan sucio!

Más arriba mencionado es un escenario muy común, hay muchos más casos de uso de por qué usar tres anotaciones.

En Spring @Component , @Service , @Controller y @Repository son anotaciones de estereotipo que se utilizan para:

@Controller: donde se realiza la asignación de solicitudes desde la página de presentación, es decir, la capa de presentación no va a ningún otro archivo va directamente a la clase @Controller y comprueba la ruta solicitada en la anotación @RequestMapping escrita antes de las llamadas al método si es necesario.

@Service : toda la lógica de negocios está aquí, es decir, cálculos relacionados con los datos y todo. Esta anotación de la capa de negocios en la que nuestro usuario no llama directamente al método de persistencia llamará a este método utilizando esta anotación. Se solicitará @Repository según la solicitud del usuario

@Repository : Esta es la capa de Persistencia (Data Access Layer) de la aplicación que solía obtener datos de la base de datos. es decir, todas las operaciones relacionadas con la Base de Datos son realizadas por el repository.

@Component : @Component tus otros componentes (por ejemplo, clases de recursos REST) ​​con un estereotipo de componente.

Indica que una clase anotada es un ” componente “. Dichas clases se consideran candidatas para la autodetección cuando se usa la configuración basada en anotaciones y el escaneo de classpath.

También se puede considerar que otras anotaciones de nivel de clase identifican un componente, generalmente un tipo especial de componente: por ejemplo, la anotación @Repository o la anotación @Aspect de AspectJ.

enter image description here

Spring 2.5 introduce más anotaciones de estereotipo: @Component, @Service y @Controller. @Component sirve como un estereotipo genérico para cualquier componente gestionado por Spring; mientras que, @Repository, @Service y @Controller sirven como especializaciones de @Component para casos de uso más específicos (por ejemplo, en las capas de persistencia, servicio y presentación, respectivamente). Lo que esto significa es que puede anotar sus clases de componente con @Component, pero al anotarlas con @Repository, @Service o @Controller, sus clases son más adecuadas para el procesamiento por herramientas o la asociación con aspectos. Por ejemplo, estas anotaciones de estereotipo son objectives ideales para los puntos de corte. Por supuesto, también es posible que @Repository, @Service y @Controller puedan llevar una semántica adicional en futuras versiones de Spring Framework. Por lo tanto, si toma una decisión entre utilizar @Component o @Service para su capa de servicio, @Service es claramente la mejor opción. Del mismo modo, como se indicó anteriormente, @Repository ya es compatible como un marcador para la traducción automática de excepciones en su capa de persistencia.

 @Component – Indicates a auto scan component. @Repository – Indicates DAO component in the persistence layer. @Service – Indicates a Service component in the business layer. @Controller – Indicates a controller component in the presentation layer. 

referencia: – Documentación de spring – Escaneo de Classpath, componentes administrados y configuraciones de escritura usando Java

 @Component – Indicates a auto scan component. @Repository – Indicates DAO component in the persistence layer. @Service – Indicates a Service component in the business layer. @Controller – Indicates a controller component in the presentation layer. 

@Repository que todos @Repository , @Service o @Controller están anotados con @Component . Entonces, ¿podemos usar solo @Component para todos los componentes para el escaneo automático? Sí, puede, y Spring escaneará automáticamente todos sus componentes con @Component anotado.

Está funcionando bien, pero no es una buena práctica para la legibilidad, siempre debes declarar @Repository , @Service o @Controller para una capa específica para que tu código sea más fácil de leer.

El uso de las anotaciones @Service y @Repository es importante desde la perspectiva de conexión de la base de datos.

  1. Use @Service para todo su tipo de servicio web de conexiones DB
  2. Use @Repository para todas sus conexiones de base de datos proc almacenadas

Si no utiliza las anotaciones adecuadas, puede enfrentar excepciones de compromiso anuladas mediante transacciones de reversión. Verás excepciones durante la prueba de carga de estrés que está relacionada con la reversión de las transacciones JDBC.

Diferencia entre @Component, @Service y @Repository

La principal diferencia entre estos estereotipos es que se usan para diferentes clasificaciones.

En una aplicación de varios niveles, tendremos diferentes capas como presentación, servicio, negocios, acceso a datos, etc. Cuando se deba anotar una clase para la detección automática de Spring, entonces debemos usar el estereotipo respectivo como se muestra a continuación.

@Component : genérico y se puede usar en toda la aplicación.
@Service : anota las clases en el nivel de capa de servicio.
@Repository : anota clases en la capa de persistencia, que actuará como depósito de la base de datos.

Si técnicamente van a ser los mismos, entonces ¿por qué tenemos que usarlos a diferentes capas? ¿Por qué no usar el mismo en todas las capas? Por ejemplo, si usamos @Service en todas las capas, se crearán instancias de todos los beans y no habrá problemas. Hay una pequeña diferencia, por ejemplo, considere @Repository .

El postprocesador busca automáticamente todos los traductores de excepción (implementaciones de la interfaz PersistenceExceptionTranslator) y aconseja todos los beans marcados con la anotación @Repository para que los traductores descubiertos puedan interceptar y aplicar la traducción adecuada en las excepciones lanzadas.

Similar a lo anterior, en el futuro Spring puede optar por agregar valor para @Service , @Controller y @Repository según sus convenciones de capas. Para esa característica adicional, es mejor respetar la convención y usarla en línea con las capas.

Aparte de lo anterior, con respecto a la autodetección de escaneo, la dependency injection para BeanDefinition @Component , @Service , @Repository , @Controller es la misma.

@Repository @Service y @Controller sirven como especialización de @Component para un uso más específico, de ese modo puede reemplazar @Service por @Component, pero en este caso pierde la especialización.

 1. **@Repository** - Automatic exception translation in your persistence layer. 2. **@Service** - It indicates that the annotated class is providing a business service to other layers within the application. 

todas estas anotaciones son del tipo de tipo de estéreo de anotación, la diferencia entre estas tres anotaciones es

  • Si agregamos el @Component, entonces nos dice que el rol de la clase es una clase de componente, significa que es una clase que consta de cierta lógica, pero no indica si una clase contiene específicamente una lógica empresarial o de persistencia o controladora, por lo que no la usamos directamente esta anotación @Component
  • Si agregamos la anotación @Service, entonces se dice que un rol de clase consiste en la lógica empresarial
  • Si agregamos @Repository en la parte superior de la clase, entonces dice que una clase consiste en lógica de persistencia
  • Aquí @Component es una anotación base para @ Service, @ Repository y @Controller annotations

por ejemplo

 package com.spring.anno; @Service public class TestBean { public void m1() { //business code } } package com.spring.anno; @Repository public class TestBean { public void update() { //persistence code } } 
  • siempre que @Service la @Service o @Repositroy o @Controller de manera predeterminada @Component anotación va a la existencia en la parte superior de la clase

En una aplicación de varios niveles, tendremos diferentes capas como presentación, servicio, negocios, acceso a datos, etc. Cuando se deba anotar una clase para la detección automática de Spring, entonces debemos usar el estereotipo respectivo como se muestra a continuación.

  • @Component : genérico y se puede usar en toda la aplicación.
  • @Service : anota las clases en el nivel de capa de servicio.
  • @Controller : anota clases a nivel de capas de presentación, principalmente usadas en Spring MVC.
  • @Repository : anota clases en la capa de persistencia, que actuará como depósito de la base de datos.

Spring proporciona cuatro tipos diferentes de anotaciones de escaneo de componentes automáticos, son @Component , @Service , @Repository y @Controller . Técnicamente, no hay diferencia entre ellos, pero cada anotación de escaneo de componentes automáticos debe usarse para un propósito especial y dentro de la capa definida.

@Component : es una anotación básica de escaneo de componentes automáticos, indica que la clase anotada es un componente de escaneo automático.

@Controller : la clase anotada indica que es un componente de controlador y se usa principalmente en la capa de presentación.

@Service : indica que la clase anotada es un componente de servicio en la capa empresarial.

@Repository : necesita usar esta anotación dentro de la capa de persistencia, esto actúa como un repository de base de datos.

Uno debe elegir una forma más especializada de @Component al anotar su clase, ya que esta anotación puede contener un comportamiento específico en el futuro.

Anote otros componentes con @Component, por ejemplo, clases de recursos REST.

 @Component public class AdressComp{ ....... ...//some code here } 

@Component es un estereotipo genérico para cualquier componente gestionado de Spring.

@Controller, @Service y @Repository son especializaciones de @Component para casos de uso específicos.

@Component en Spring

1. La principal diferencia entre estos estereotipos es que se utilizan para diferentes clasificaciones.

2. En una aplicación de varios niveles, tendremos diferentes capas, como presentación, servicio, negocios, acceso a datos, etc. Cuando se deba anotar una clase para la autodetección por Spring, entonces debemos usar el estereotipo respectivo como se muestra a continuación.

  • @Component : genérico y se puede usar en toda la aplicación.
  • @Service : anota las clases en el nivel de capa de servicio.
  • @Controller : anota clases a nivel de capas de presentación, principalmente usadas en Spring MVC.
  • @Repository : anota clases en la capa de persistencia, que actuará como depósito de la base de datos. Si técnicamente van a ser los mismos, entonces ¿por qué tenemos que usarlos a diferentes capas? ¿Por qué no usar el mismo en todas las capas? Por ejemplo, si usamos @Service en todas las capas, se crearán instancias de todos los beans y no habrá problemas. Hay una pequeña diferencia, por ejemplo, considere @Repository.

El postprocesador busca automáticamente todos los traductores de excepción (implementaciones de la interfaz PersistenceExceptionTranslator) y aconseja todos los beans marcados con la anotación @Repository para que los traductores descubiertos puedan interceptar y aplicar la traducción adecuada en las excepciones lanzadas.

  1. Similar a lo anterior, en el futuro Spring puede optar por agregar valor para @Service , @Controller y @Repository según sus convenciones de capas. Para esa ventaja de características adicionales, es mejor respetar la convención y usarlas en línea con las capas.
  2. Aparte de lo anterior, con respecto a la autodetección de escaneo , la dependency injection para BeanDefinition @Component , @Service , @Repository , @Controller es la misma.
  3. Según la documentación de Spring: la anotación @Repository es un marcador para cualquier clase que cumpla la función o el estereotipo de un repository (también conocido como Data Access Object o DAO ). Entre los usos de este marcador está la traducción automática de excepciones como se describe en la Sección 20.2.2, “Traducción de excepciones”. Spring proporciona más anotaciones de estereotipos: @Component, @Service y @Controller . @Component es un estereotipo genérico para cualquier componente gestionado por Spring . @Repository, @Service y @Controller son las especializaciones de @Component para casos de uso más específicos , por ejemplo, en las capas de persistencia, servicio y presentación, respectivamente. Por lo tanto, puede anotar sus clases de componentes con @Component, pero al anotarlas con @Repository, @Service o @Controller, sus clases son más adecuadas para el procesamiento por herramientas o la asociación con aspectos. Por ejemplo, estas anotaciones de estereotipo son objectives ideales para los puntos de corte. También es posible que @Repository, @Service y @Controller puedan tener una semántica adicional en futuras versiones de Spring Framework. Por lo tanto, si elige entre usar @Component o @Service para su capa de servicio, @Service es claramente la mejor opción. Del mismo modo, como se indicó anteriormente, @Repository ya es compatible como un marcador para la traducción automática de excepciones en su capa de persistencia.

Podemos responder esto de acuerdo con el estándar de Java

En referencia a JSR-330 , que ahora es compatible con la spring, solo puede usar @Named para definir un bean (Somehow @Named=@Component ). De acuerdo con esta norma, parece que no sirve de nada definir estereotipos (como @Repository , @Service , @Controller ) a categorías beans.

Pero usuario de spring estas anotaciones diferentes en diferentes para el uso específico, por ejemplo:

  1. Ayude a los desarrolladores a definir una categoría mejor para el competente. Esta categorización puede ser útil en algunos casos. (Por ejemplo, cuando se usa aspect-oriented , estos pueden ser un buen candidato para los pointcuts )
  2. @Repository anotación @Repository agregará cierta funcionalidad a su bean (alguna traducción de excepción automática a su capa de persistencia de bean).
  3. Si está utilizando Spring MVC, @RequestMapping solo se puede agregar a las clases anotadas por @Controller .

Técnicamente @Controller, @Service, @Repository son todos iguales. Todos ellos extienden @Components.

Desde el código fuente de Spring:

Indica que una clase anotada es un “componente”. Dichas clases se consideran candidatas para la autodetección cuando se usa la configuración basada en anotaciones y el escaneo de classpath.

Podemos usar directamente @Component para todos y cada uno de los beans, pero para una mejor comprensión y mantenibilidad de una aplicación grande, usamos @Controller, @Service, @Repository.

Propósito de cada anotación:

1) @Controller -> Las clases anotadas con esto, están destinadas a recibir una solicitud del lado del cliente. La primera solicitud llega al Servlet Dispatcher, desde donde pasa la solicitud al controlador particular utilizando el valor de la anotación @RequestMapping.

2) @Service -> Las clases anotadas con esto, están destinadas a manipular datos, que recibimos del cliente o de la base de datos. Toda la manipulación con datos debería hacerse en esta capa.

3) @Repository -> Las clases anotadas con esto, están destinadas a conectarse con la base de datos. También se puede considerar como capa DAO (Objeto de acceso a datos). Esta capa debe restringirse solo a las operaciones CRUD (crear, recuperar, actualizar, eliminar). Si se requiere alguna manipulación, los datos deben enviarse de vuelta a la capa @Service.

Si intercambiamos su lugar (use @Repository en lugar de @Controller), nuestra aplicación funcionará bien.

El objective principal de utilizar tres @anotaciones diferentes es proporcionar una mejor modularidad a la aplicación Enterprise.

Las @Component Spring @Component , @Service , @Repository y @Controller se utilizan para la detección automática de bean utilizando classpath scan en Spring framework.

@Component es una anotación genérica. La diferencia de @Service , @Repository , @Controller con @Component es que son casos especiales de @Component y se usan para propósitos particulares. La diferencia es solo clasificación.

Para todas estas anotaciones (estereotipos), técnicamente el propósito principal es el mismo. Spring escanea e identifica automáticamente todas estas clases que están anotadas con ” @Component , @Service , @Repository , @Controller ” y registra la definición de Bean con ApplicationContext .

En spring 4, última versión:

La anotación @Repository es un marcador para cualquier clase que cumpla la función o el estereotipo de un repository (también conocido como Objeto de acceso a datos o DAO). Entre los usos de este marcador está la traducción automática de excepciones como se describe en la Sección 20.2.2, “Traducción de excepciones”.

Spring proporciona más anotaciones de estereotipos: @Component, @Service y @Controller. @Component es un estereotipo genérico para cualquier componente gestionado por Spring. @Repository, @Service y @Controller son especializaciones de @Component para casos de uso más específicos, por ejemplo, en las capas de persistencia, servicio y presentación, respectivamente. Por lo tanto, puede anotar sus clases de componentes con @Component, pero al anotarlas con @Repository, @Service o @Controller, sus clases son más adecuadas para el procesamiento por herramientas o la asociación con aspectos. Por ejemplo, estas anotaciones de estereotipo son objectives ideales para los puntos de corte. También es posible que @Repository, @Service y @Controller puedan tener una semántica adicional en futuras versiones de Spring Framework. Por lo tanto, si elige entre usar @Component o @Service para su capa de servicio, @Service es claramente la mejor opción. Similarly, as stated above, @Repository is already supported as a marker for automatic exception translation in your persistence layer.

Even if we interchange @Component or @Repository or @service

It will behave the same , but one aspect is that they wont be able to catch some specific exception related to DAO instead of Repository if we use component or @ service

There is no difference between @Component,@Service,@Controller,@Repository. @Component is the Generic annotation to represent the component of our MVC. But there will be several components as part of our MVC application like service layer components, persistence layer components and presentation layer components. So to differentiate them Spring people have given the other three annotations also.

To represent persistence layer components : @Repository

To represent service layer components : @Service

To represent presentation layer components : @Controller

or else you can use @Component for all of them.

@Component is the top level generic annotation which makes the annotated bean to be scanned and available in the DI container

@Repository is specialized annotation and it brings the feature of converting all the unchecked exceptions from the DAO classes

@Service is specialized annotation. it do not bring any new feature as of now but it clarifies the intent of the bean

@Controller is specialized annotation which makes the bean MVC aware and allows the use of further annotation like @RequestMapping and all such

Here are more details

@Component : you annotate a class @Component, it tells hibernate that it is a Bean.

@Repository : you annotate a class @Repository, it tells hibernate it is a DAO class and treat it as DAO class. Means it makes the unchecked exceptions (thrown from DAO methods) eligible for translation into Spring DataAccessException.

@Service : This tells hibernate it is a Service class where you will have @Transactional etc Service layer annotations so hibernate treats it as a Service component.

Plus @Service is advance of @Component. Assume the bean class name is CustomerService, since you did not choose XML bean configuration way so you annotated the bean with @Component to indicate it as a Bean. So while getting the bean object CustomerService cust = (CustomerService)context.getBean("customerService"); By default, Spring will lower case the first character of the component – from ‘CustomerService’ to ‘customerService’. And you can retrieve this component with name ‘customerService’. But if you use @Service annotation for the bean class you can provide a specific bean name by

 @Service("AAA") public class CustomerService{ 

and you can get the bean object by

 CustomerService cust = (CustomerService)context.getBean("AAA"); 

A @Service to quote spring documentation,

Indicates that an annotated class is a “Service”, originally defined by Domain-Driven Design (Evans, 2003) as “an operation offered as an interface that stands alone in the model, with no encapsulated state.” May also indicate that a class is a “Business Service Facade” (in the Core J2EE patterns sense), or something similar. This annotation is a general-purpose stereotype and individual teams may narrow their semantics and use as appropriate.

If you look at domain driven design by eric evans,

A SERVICE is an operation offered as an interface that stands alone in the model, without encapsulating state, as ENTITIES and VALUE OBJECTS do. SERVICES are a common pattern in technical frameworks, but they can also apply in the domain layer. The name service emphasizes the relationship with other objects. Unlike ENTITIES and VALUE OBJECTS, it is defined purely in terms of what it can do for a client. A SERVICE tends to be named for an activity, rather than an entity—a verb rather than a noun. A SERVICE can still have an abstract, intentional definition; it just has a different flavor than the definition of an object. A SERVICE should still have a defined responsibility, and that responsibility and the interface fulfilling it should be defined as part of the domain model. Operation names should come from the UBIQUITOUS LANGUAGE or be introduced into it. Parameters and results should be domain objects. SERVICES should be used judiciously and not allowed to strip the ENTITIES and VALUE OBJECTS of all their behavior. But when an operation is actually an important domain concept, a SERVICE forms a natural part of a MODEL-DRIVEN DESIGN. Declared in the model as a SERVICE, rather than as a phony object that doesn’t actually represent anything, the standalone operation will not mislead anyone.

and a Repository as per Eric Evans,

A REPOSITORY represents all objects of a certain type as a conceptual set (usually emulated). It acts like a collection, except with more elaborate querying capability. Objects of the appropriate type are added and removed, and the machinery behind the REPOSITORY inserts them or deletes them from the database. This definition gathers a cohesive set of responsibilities for providing access to the roots of AGGREGATES from early life cycle through the end.

@Component This annotation is used on classes to indicate a Spring component.It marks the Java class as a bean or component so that the component-scanning mechanism of Spring can add it into the application context.

@Repository This annotation is used on Java classes that directly access the database.It works as a marker for any class that fulfills the role of repository or Data Access Object.This annotation has an automatic translation feature. For example, when an exception occurs in the @Repository, there is a handler for that exception and there is no need to add a try-catch block.

@Service It marks a Java class that performs some service, such as executing business logic, performing calculations, and calling external APIs. This annotation is a specialized form of the @Component annotation intended to be used in the service layer.

@Controller This annotation is used to indicate the class is a Spring controller.

Explanation of stereotypes :

  • @Service – Annotate all your service classes with @Service. This layer knows the unit of work. All your business logic will be in Service classes. Generally methods of service layer are covered under transaction. You can make multiple DAO calls from service method, if one transaction fails all transactions should rollback.
  • @Repository – Annotate all your DAO classes with @Repository. All your database access logic should be in DAO classes.
  • @Component – Annotate your other components (for example REST resource classes) with component stereotype.
  • @Autowired – Let Spring auto-wire other beans into your classes using @Autowired annotation.

@Component is a generic stereotype for any Spring-managed component. @Repository , @Service , and @Controller are specializations of @Component for more specific use cases, for example, in the persistence, service, and presentation layers, respectively.

Originally answered here .

@Component – generic and can be used across application. @Service – annotate classes at service layer level. @Repository – annotate classes at persistence layer, which will act as database repository.

In spring framework provides some special type of annotations,called stereotype annotations. These are following:-

 @RestController- Declare at controller level. @Controller – Declare at controller level. @Component – Declare at Bean/entity level. @Repository – Declare at DAO level. @Service – Declare at BO level. 

above declared annotations are special because when we add into xxx-servlet.xml file ,spring will automatically create the object of those classes which are annotated with above annotation during context creation/loading phase.

@Component, @ Repository, @ Service, @Controller:

@Component is a generic stereotype for the components managed by Spring @Repository, @Service, and @Controller are @Component specializations for more specific uses:

  • @Repository for persistence
  • @Service for services and transactions
  • @Controller for MVC controllers

Why use @Repository, @Service, @Controller over @Component? We can mark our component classes with @Component, but if instead we use the alternative that adapts to the expected functionality. Our classes are better suited to the functionality expected in each particular case.

A class annotated with “@Repository” has a better translation and readable error handling with org.springframework.dao.DataAccessException. Ideal for implementing components that access data (DataAccessObject or DAO).

An annotated class with “@Controller” plays a controller role in a Spring Web MVC application

An annotated class with “@Service” plays a role in business logic services, example Facade pattern for DAO Manager (Facade) and transaction handling

 @component @controller @Repository @service @RestController 

These are all StereoType annotations. If we placed @controller on top of class. It will not become controller class based on the different layers(components) we can annotate with this annotations but compiler will not do anything about this just for developer understanding purpose we can choose based on the components which annotations we have to write