Desde Documentación de primavera:

EL @Repository La anotación es un marcador para cualquier clase que cumple el rol o estereotipo de un repositorio (también conocido como Objeto de acceso a datos o DAO). Entre los usos de este marcador se encuentra la traducción automática de excepciones, como se describe en Traducción de excepción.

Spring proporciona más anotaciones de estereotipos: @Component, @Servicey @Controller. @Component es un estereotipo genérico para cualquier componente administrado por Spring. @Repository, @Service y @Controller son especializaciones de @Component para casos de uso más específicos (en las capas de persistencia, servicio y presentación, respectivamente). Por lo tanto, puede anotar sus clases de componentes con @Component, pero, anotándolos con @Repository, @Serviceo @Controller en cambio, sus clases son más adecuadas para procesarlas con herramientas o asociarlas con aspectos.

Por ejemplo, estas anotaciones de estereotipos son objetivos ideales para los puntos. @Repository, @Service y @Controller también puede incluir semántica adicional en futuras versiones de Spring Framework. Por lo tanto, si elige entre usar @Component or @Service para su capa de servicio, @Service es claramente la mejor opción. Del mismo modo, como se dijo anteriormente, @Repository ya se admite como marcador para la traducción automática de excepciones en su capa de persistencia.

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

Primero el Similitud

El primer punto que vale la pena destacar nuevamente es que con respecto a la detección automática de escaneo y la inyección de dependencia para BeanDefinition todas estas anotaciones (a saber, @Component, @Service, @Repository, @Controller) son iguales. Podemos usar uno en lugar de otro y todavía podemos movernos.

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 resorte.

¿Qué tiene de especial @Component?
<context:component-scan> solo escaneos @Component y no busca @Controller, @Service y @Repository en general. Se escanean porque ellos mismos están anotados con @Component.

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

@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 @Component anotación. <context:component-scan> los recoge y registra sus siguientes clases como frijoles, como si estuvieran anotados con @Component.

Las anotaciones de tipo especial también se escanean, porque ellas mismas están anotadas con @Component anotación, lo que significa que también son @Components. Si definimos nuestra propia anotación personalizada y la anotamos con @Component, también se escaneará con <context:component-scan>

@Repositorio

Esto es para indicar que la clase define un repositorio de datos.

¿Qué tiene de especial @Repository?

Además de señalar, que esta es una Configuración basada en anotaciones, @RepositoryEl trabajo es detectar excepciones específicas de la plataforma y volver a lanzarlas como una de las excepciones unificadas sin marcar de Spring. Para ello contamos con PersistenceExceptionTranslationPostProcessor, que debemos agregar en el contexto de la aplicación de Spring como este:

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

Este postprocesador de frijoles agrega un asesor a cualquier frijol anotado con @Repository para que las excepciones específicas de la plataforma se detecten y luego se vuelvan a lanzar como una de las excepciones de acceso a datos no verificadas de Spring.

@Controlador

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

¿Qué tiene de especial @Controller?

No podemos cambiar esta anotación con ninguna otra como @Service or @Repository, aunque tengan el mismo aspecto. El despachador escanea las clases anotadas con @Controller y detecta métodos anotados con @RequestMapping anotaciones dentro de ellos. Nosotros podemos usar @RequestMapping en / en solo aquellos métodos cuyas clases están anotadas con @Controller y lo hará NO trabajar con @Component, @Service, @Repository etc ...

_{Nota: Si una clase ya está registrada como un bean a través de cualquier método alternativo, como a través de @Bean o a través de @Component, @Service etc ... anotaciones, entonces @RequestMapping se puede elegir si la clase también está anotada con @RequestMapping anotación. Pero ese es un escenario diferente.}

@Servicio

@Service Los beans contienen la lógica empresarial y los métodos de llamada en la capa de repositorio.

¿Qué tiene de especial @Service?

Aparte del hecho de que se usa para indicar que mantiene la lógica empresarial, no hay nada más notable en esta anotación; pero quién sabe, Spring puede agregar algo más excepcional en el futuro.

¿Qué más?

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

Son casi iguales: todos significan que la clase es un bean Spring. @Service, @Repository y @Controller son especializados @Components. Puede optar por realizar acciones específicas con ellos. Por ejemplo:

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

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

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

Por ejemplo, recientemente hice:

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

Entonces todas las clases anotadas con @ScheduledJob son frijoles de primavera y además de eso se registran como trabajos de cuarzo. Solo tiene que proporcionar el código que maneja la anotación específica.

@Component es equivalente a

<bean>

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

Eso significa que el Servicio, el Controlador y el Repositorio son funcionalmente iguales.

Las tres anotaciones se utilizan para separar "Capas" en su aplicación,

• Los controladores simplemente hacen cosas como enviar, reenviar, llamar a métodos de servicio, etc.
• Servicio Hold Lógica empresarial, cálculos, etc.
• El repositorio son los DAO (Data Access Objects), acceden directamente a la base de datos.

Ahora puede preguntar por qué separarlos: (supongo que conoce la programación orientada a aspectos AOP)

Supongamos que desea supervisar la actividad de la capa DAO únicamente. Escribirá una clase de Aspect (clase A) que realiza algunos registros antes y después de que se invoque cada método de su DAO, puede hacerlo usando AOP ya que tiene tres Capas distintas y no están mezcladas.

Por lo tanto, puede hacer el registro de DAO "alrededor", "antes" o "después" de los métodos DAO. Podrías hacer eso porque tenías un DAO en primer lugar. Lo que acabas de lograr es Separación de preocupaciones o tareas.

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

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

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

@Controller: donde su solicita mapeo de la página de presentación hecho, es decir, la capa de presentación no irá a ningún otro archivo al que vaya directamente @Controller class y comprueba la ruta solicitada en @RequestMapping anotación que se escribió antes de las llamadas al método si es necesario.

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

@Repository: Esta es la capa de persistencia (capa de acceso a datos) 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 las realiza el repositorio.

@Component - Anote sus otros componentes (por ejemplo, clases de recursos REST) ​​con un estereotipo de componente.

Indica que una clase anotada es "componente". Estas clases se consideran candidatas para la detección automática cuando se utiliza una configuración basada en anotaciones y un escaneo de rutas de clases.

También se pueden considerar otras anotaciones a nivel de clase como identificación de un componente, normalmente un tipo especial de componente: por ejemplo, la anotación @Repository o la anotación @Aspect de AspectJ.

Spring 2.5 introduce más anotaciones de estereotipos: @Component, @Service y @Controller. @Component sirve como un estereotipo genérico para cualquier componente administrado 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 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 estereotipos son objetivos ideales para los puntos de corte. Por supuesto, también es posible que @Repository, @Service y @Controller incluyan semántica adicional en futuras versiones de Spring Framework. Por lo tanto, si está tomando una decisión entre usar @Component o @Service para su capa de servicio, @Service es claramente la mejor opción. De manera similar, 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: - Spring Documentation: escaneo de Classpath, componentes administrados y configuraciones de escritura usando Java

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

Desde el código fuente de Spring:

Indica que una clase anotada es un "componente". Estas clases se consideran candidatas para la detección automática cuando se utiliza una configuración basada en anotaciones y un escaneo de rutas de clases.

Podemos usar directamente @Component para todos y cada uno de los beans, pero para una mejor comprensión y capacidad de mantenimiento de una aplicación grande, utilizamos @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 Dispatcher Servlet, desde donde pasa la solicitud al controlador particular utilizando el valor de @RequestMapping anotación.
2. @Service -> Las clases anotadas con esto, están destinadas a manipular datos, que recibimos del cliente o recuperamos de la base de datos. Toda la manipulación con datos debe realizarse 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 estar restringida a operaciones CRUD (crear, recuperar, actualizar, eliminar) únicamente. Si se requiere alguna manipulación, los datos deben enviarse a la capa @Service.

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

El objetivo principal de utilizar tres diferentes @annotations es proporcionar una mejor modularidad a la aplicación empresarial.

El uso de @Service y @Repository las anotaciones son importantes desde la perspectiva de la conexión a la base de datos.

1. Utilice la herramienta @Service para todos los tipos de conexiones de base de datos de su servicio web
2. Utilice la herramienta @Repository para todas sus conexiones de base de datos proc almacenadas

Si no usa las anotaciones adecuadas, puede enfrentar excepciones de confirmación anuladas por transacciones de reversión. Verá excepciones durante la prueba de carga de esfuerzo relacionada con la reversión de transacciones JDBC.

@Repositorio @Servicio y @Controlador Estos sirven como especialización de @Component para un uso más específico sobre esa base, 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 un tipo de tipo estéreo tipo de anotación, la diferencia entre estas tres anotaciones es

• Si agregamos el @Component, entonces 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 dice si una clase contiene una lógica de controlador, persistencia o comercial específica, por lo que no la usamos. directamente esta anotación @Component
• Si agregamos la anotación @Service, indica que un rol de clase que consiste en lógica de negocios
• Si agregamos @Repository en la parte superior de la clase, entonces dice que una clase que consiste en lógica de persistencia
• Aquí @Component es una anotación base para las anotaciones @ Service, @ Repository y @Controller

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
    }
}

• cada vez que agregamos el @Service or @Repositroy or @Controller anotación por defecto @Component la anotación va a existir en la parte superior de la clase

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 repositorio de la base de datos.

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

No hay diferencia entre @Component, @Service, @Controller, @Repository. @Component es la anotación genérica para representar el componente de nuestro MVC. Pero habrá varios componentes como parte de nuestra aplicación MVC, como componentes de la capa de servicio, componentes de la capa de persistencia y componentes de la capa de presentación. Entonces, para diferenciarlos, la gente de Spring también ha dado las otras tres anotaciones.

• Para representar los componentes de la capa de persistencia: @Repository
• Para representar los componentes de la capa de servicio: @Service
• Para representar los componentes de la capa de presentación: @Controller
• o de lo contrario puedes usar @Component para todos ellos.

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 administrado por Spring.

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

@Componente en primavera

Podemos responder a esto de acuerdo con el estándar java.

Refiriéndose a JSR-330, que ahora es compatible con Spring, solo puede usar @Named para definir un frijol (de alguna manera @Named=@Component). Entonces, de acuerdo con este estándar, parece que no sirve de nada definir estereotipos (como @Repository, @Service, @Controller) a las categorías de frijoles.

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

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

Incluso si intercambiamos @Component o @Repository o @service

Se comportará igual, pero un aspecto es que no podrán detectar alguna excepción específica relacionada con DAO en lugar de Repository si usamos componente o @ service

@Componente: anotas una clase @Component, le dice a Hibernate que es un Bean.

@Repositorio: anotas una clase @Repository, le dice a hibernate que es una clase DAO y la trata como una clase DAO. Significa que hace que las excepciones no verificadas (lanzadas desde los métodos DAO) sean elegibles para la traducción a Spring DataAccessException.

@Servicio: Esto le dice a hibernate que es una clase de servicio donde tendrá @Transactional etc Anotaciones de la capa de servicio para que hibernate lo trate como un componente de servicio.

MÁS @Service es el avance de @Component. Suponga que el nombre de la clase de frijol es CustomerService, ya que no eligió la forma de configuración del bean XML, por lo que anotó el bean con @Component para indicarlo como un Bean. Entonces, al obtener el objeto de frijol CustomerService cust = (CustomerService)context.getBean("customerService"); De forma predeterminada, Spring pondrá en minúsculas el primer carácter del componente, desde 'CustomerService' hasta 'customerService'. Y puede recuperar este componente con el nombre 'customerService'. Pero si usas @Service anotación para la clase de bean, puede proporcionar un nombre de bean específico mediante

@Service("AAA")
public class CustomerService{

y puedes obtener el objeto bean por

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

En Spring 4, última versión:

La anotación @Repository es un marcador para cualquier clase que cumpla el rol o estereotipo de un repositorio (también conocido como objeto de acceso a datos o DAO). Entre los usos de este marcador se encuentra 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 administrado 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 estereotipos son objetivos ideales para los puntos de corte. También es posible que @Repository, @Service y @Controller incluyan 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. De manera similar, 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 es la anotación genérica de nivel superior que hace que el bean anotado se escanee y esté disponible en el contenedor DI

@Repository es una anotación especializada y trae la característica de convertir todas las excepciones no marcadas de las clases DAO

@Service es una anotación especializada. no trae ninguna característica nueva a partir de ahora, pero aclara la intención del bean

@Controller es una anotación especializada que hace que el bean MVC sea consciente y permite el uso de anotaciones adicionales como @RequestMapping y todo eso

Éstos son más detalles

Aquí hay respuestas suficientemente buenas para explicar cuál es la diferencia entre las anotaciones de servicio de repositorio de componentes. Me gustaría compartir la diferencia entre @Controller & @RestController

@Controller vs RestController

@RestController:

• Esta anotación es una versión especializada de @Controller que agrega @Controller y @ResponseBody anotación automáticamente. para que no tengamos que agregar @ResponseBody a nuestros métodos de mapeo. Eso significa @ResponseBody está activo por defecto.
• Si utiliza @RestController no puede devolver una vista (al usar Viewresolver en primavera / arranque de primavera)
• @RestController también convierte la respuesta a JSON/XML automatically as @ResponseBody convierte los objetos devueltos en algo que podría estar en el cuerpo, e.g. JSON or XML

@Controller

• @Controller se usa para marcar clases como Spring MVC Controller. Esta anotación es solo una versión especializada de @Component y permite que las clases de controlador se detecten automáticamente en función del escaneo de classpath.
• @Controller puede devolver una vista en Spring web MVC.

Vista más detallada

A @Service para citar documentación de primavera,

Indica que una clase anotada es un "Servicio", originalmente definido por Domain-Driven Design (Evans, 2003) como "una operación ofrecida como una interfaz que se encuentra sola en el modelo, sin un estado encapsulado". También puede indicar que una clase es una "Fachada de servicios empresariales" (en el sentido de los patrones Core J2EE) o algo similar. Esta anotación es un estereotipo de propósito general y los equipos individuales pueden limitar su semántica y usarla según corresponda.

Si observa el diseño impulsado por dominios de eric evans,

Un SERVICIO es una operación que se ofrece como una interfaz que se encuentra sola en el modelo, sin encapsular el estado, como lo hacen las ENTIDADES y los OBJETOS DE VALOR. Los SERVICIOS son un patrón común en los marcos técnicos, pero también pueden aplicarse en la capa de dominio. El servicio de nombres enfatiza la relación con otros objetos. A diferencia de ENTIDADES y OBJETOS DE VALOR, se define puramente en términos de lo que puede hacer por un cliente. Un SERVICIO tiende a ser nombrado por una actividad, en lugar de una entidad, un verbo en lugar de un sustantivo. Un SERVICIO todavía puede tener una definición abstracta e intencional; simplemente tiene un sabor diferente al de la definición de un objeto. Un SERVICIO debe tener una responsabilidad definida, y esa responsabilidad y la interfaz que la cumple deben definirse como parte del modelo de dominio. Los nombres de las operaciones deben provenir del LENGUAJE UBIQUITO o introducirse en él. Los parámetros y los resultados deben ser objetos de dominio. Los SERVICIOS deben usarse con prudencia y no se debe permitir despojar a las ENTIDADES y OBJETOS DE VALOR de todo su comportamiento. Pero cuando una operación es en realidad un concepto de dominio importante, un SERVICIO forma parte natural de un DISEÑO IMPULSADO POR MODELO. Declarada en el modelo como un SERVICIO, en lugar de como un objeto falso que en realidad no representa nada, la operación independiente no engañará a nadie.

y Repository según Eric Evans,

Un repositorio representa todos los objetos de un cierto tipo como un conjunto conceptual (generalmente emulado). Actúa como una colección, excepto con una capacidad de consulta más elaborada. Los objetos del tipo apropiado se agregan y eliminan, y la maquinaria detrás del REPOSITORIO los inserta o elimina de la base de datos. Esta definición reúne un conjunto coherente de responsabilidades para proporcionar acceso a las raíces de los ÁRIDOS desde el ciclo de vida temprano hasta el final.

Las respuestas presentadas aquí son parcialmente técnicamente correctas, pero aunque la lista de respuestas es larga y estará en la parte inferior, pensé que valía la pena poner una respuesta realmente correcta aquí también, en caso de que alguien se tope con ella y aprenda algo valioso de eso. No es que el resto de las respuestas estén completamente equivocadas, es solo que no son correctas. Y, para detener las hordas de trolls, sí, sé que técnicamente estas anotaciones son efectivamente lo mismo en este momento y en su mayoría intercambiables incluso hasta la primavera 5. Ahora, para la respuesta correcta:

Estas tres anotaciones son cosas completamente diferentes y no son intercambiables. Puede decirlo porque hay tres de ellos en lugar de solo uno. No están destinados a ser intercambiables, simplemente se implementan de esa manera por elegancia y conveniencia.

La programación moderna es invención, arte, técnica y comunicación, en proporciones variables. El bit de comunicación suele ser muy importante porque el código suele leerse con mucha más frecuencia de lo que se escribe. Como programador, no solo está tratando de resolver el problema técnico, sino que también está tratando de comunicar su intención a los futuros programadores que lean su código. Es posible que estos programadores no compartan su idioma nativo ni su entorno social, y es posible que estén leyendo su código dentro de 50 años (no es tan improbable como podría pensar). Es difícil comunicarse de manera efectiva tan lejos en el futuro. Por lo tanto, es vital que usemos el lenguaje más claro, eficiente, correcto y comunicativo disponible para nosotros. Que elegimos nuestras palabras con cuidado para tener el máximo impacto y ser lo más claros posible en cuanto a nuestra intención.

Por ejemplo, es vital que @Repository se usa cuando escribimos un repositorio, en lugar de @Component. Esta última es una opción muy pobre de anotación para un repositorio porque no indica que estemos viendo un repositorio. Podemos suponer que un repositorio es también un spring-bean, pero no que un componente sea un repositorio. Con @Repository estamos siendo claros y específicos en nuestro idioma. Estamos afirmando claramente que se trata de un repositorio. Con @Component dejamos que el lector decida qué tipo de componente está leyendo, y tendrá que leer toda la clase (y posiblemente un árbol de subclases e interfaces) para inferir el significado. La clase podría ser malinterpretada por un lector en un futuro lejano como si no fuera un repositorio, y habríamos sido parcialmente responsables de este error porque nosotros, que sabíamos muy bien que se trataba de un repositorio, no pudimos ser específicos en nuestro idioma. y comunicar de forma eficaz nuestra intención.

No entraré en los otros ejemplos, pero lo diré tan claramente como pueda: estas anotaciones son cosas completamente diferentes y deben usarse de manera apropiada, según su intención. @Repository es para repositorios de almacenamiento y ninguna otra anotación es correcta. @Service es para servicios y ninguna otra anotación es correcta. @Component es para componentes que no son repositorios ni servicios, y usar cualquiera de estos en su lugar también sería incorrecto. Podría compilarse, incluso podría ejecutarse y aprobar sus pruebas, pero estaría mal y pensaría menos en usted (profesionalmente) si hiciera esto.

Hay ejemplos de esto a lo largo de la primavera (y la programación en general). No debes usar @Controller al escribir una API REST, porque @RestController está disponible. No debes usar @RequestMapping cuando @GetMapping es una alternativa válida. Etc. Etc. Etc. Tú debe: Elija el lenguaje más específico, exacto y correcto que pueda para comunicar su intención a sus lectores; de lo contrario, está introduciendo riesgos en su sistema y el riesgo tiene un costo.

Por último, me gustaría plantear una cuestión de orden sobre los sistemas orientados a objetos. Una de las reglas fundamentales es que las implementaciones pueden variar, pero las interfaces no. Asumir que estas anotaciones son lo mismo es una pendiente muy resbaladiza y completamente en contra de OO. Aunque pueden implementarse de manera intercambiable ahora, no hay garantía de que lo sean en el futuro. Además, incluso dentro del mismo equipo, un ingeniero puede decidir colgar algún comportamiento de una o más de estas anotaciones usando aspectos, o un ingeniero de plataforma puede optar por reemplazar la implementación de uno de estos por razones operativas. Simplemente no lo sabe, ni debería hacerlo: en OO, confía en la interfaz, no en la implementación.

Repositorio y Servicio son hijos de Componente anotación. Entonces, todos ellos son Componente. Repositorio y Servicio simplemente amplíelo. ¿Cómo exactamente? Servicio sólo tiene diferencia ideológica: lo usamos para servicios. Repositorio tiene un manejador de excepciones particular.

Explicación de estereotipos:

• @Service - Anote todas sus clases de servicio con @Service. Esta capa conoce la unidad de trabajo. Toda su lógica empresarial estará en clases de servicio. Generalmente, los métodos de la capa de servicio están cubiertos por transacción. Puede realizar varias llamadas DAO desde el método de servicio, si una transacción falla, todas las transacciones deben revertirse.
• @Repository - Anote todas sus clases DAO con @Repository. Toda la lógica de acceso a su base de datos debe estar en clases DAO.
• @Component - Anote sus otros componentes (por ejemplo, clases de recursos REST) ​​con estereotipo de componente.
• @Autowired - Deje que Spring conecte automáticamente otros beans en sus clases usando la anotación @Autowired.

@Component es un estereotipo genérico para cualquier componente administrado 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.

Respondido originalmente aquí.

Diferencia entre las anotaciones @Component, @Repository, @Controller y @Service

@Component: genérico y se puede usar en todas las aplicaciones.
@Service: anota clases a nivel de capa de servicio.
@Controller: anota clases a nivel de capas de presentación, que se utilizan principalmente en Spring MVC.
@Repository: anota las clases en la capa de persistencia, que actuará como repositorio de la base de datos.

@Controller = @Component (anotación interna) + Características de la capa de presentación
@Service = @Component (anotación interna) + Características de la capa de servicio
@Component = Componentes reales (frijoles)
@Repository = @Component (anotación interna) + Características de la capa de datos (se usa para manejar los beans de dominio)

En Spring Framework proporciona un tipo especial de anotaciones, llamadas anotaciones estereotipadas. Estos son los siguientes: -

@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.

las anotaciones declaradas anteriormente son especiales porque cuando agregamos <context:component-scan> en el archivo xxx-servlet.xml, Spring creará automáticamente el objeto de esas clases que están anotadas con la anotación anterior durante la fase de creación / carga del contexto.

@Componente actúa como una anotación @Bean en la clase de configuración, registra el bean en el contexto de primavera. También es padre para la anotación @Service, @Repository y @Controller.

@Servicio, extiende la anotación @Component y solo tiene una diferencia de nombre.

@Repositorio - extiende la anotación @Component y traduce todas las excepciones de la base de datos a Excepción de acceso a datos.

@Controlador - actúa como controlador en el patrón MVC. El despachador escaneará dichas clases anotadas en busca de métodos mapeados, detectando anotaciones @RequestMapping.

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

@Component es un estereotipo genérico para los componentes administrados por Spring @Repository, @Service y @Controller Fuck Cancer. @Component especializaciones para usos más específicos:

• @Repository por persistencia
• @Service para servicios y transacciones
• @Controller para controladores MVC

¿Por qué utilizar @Repository, @Service, @Controller encima @Component? Podemos marcar nuestras clases de componentes con @Component, pero si en cambio usamos la alternativa que se adapta a la funcionalidad esperada. Nuestras clases se adaptan mejor a la funcionalidad esperada en cada caso particular.

Una clase anotada con @Repository tiene una mejor traducción y un manejo de errores legible con org.springframework.dao.DataAccessException. Ideal para implementar componentes que acceden a datos (DataAccessObject o DAO).

Una clase anotada con @Controller juega un papel de controlador en una aplicación Spring Web MVC

Una clase anotada con @Service Desempeña un papel en los servicios de lógica empresarial, ejemplo Patrón de fachada para DAO Manager (Fachada) y manejo de transacciones

Para simplificar esta ilustración, consideremos el tecnicismo por caso de uso, estas anotaciones se utilizan para ser inyectadas y como dije literalmente "Solía ​​ser inyectado", es decir, si sabe cómo utilizar Inyección de dependencia "DI" y debería, entonces siempre buscará estas anotaciones, y anotando las clases con estas Tipos de estéreo, estás informando al DI contenedor para escanearlos y estar listos para la inyección en otros lugares, este es el objetivo práctico.

Ahora pasemos a cada uno; primero @Servicio, Si está construyendo alguna lógica para un caso comercial específico, debe separar eso en un lugar que contendrá su lógica comercial, este servicio es Clase normal o puede usarlo como interfaz si lo desea, y está escrito así

@Service
public class Doer {
   // Your logic 
}

// To use it in another class, suppose in Controller 
@Controller
public class XController {
 // You have to inject it like this 
 @Autowired 
 private Doer doer;
}

Todos son de la misma manera cuando los inyecta, @Repositorio es una interfaz que aplica la implementación del patrón de repositorio Patrón de diseño del repositorio, generalmente se usa cuando se trata de algún almacén de datos o base de datos, y encontrará que contiene múltiples implementaciones listas para manejar las operaciones de la base de datos; puede ser Repositorio Crud, JpaRepositorio etc.

// For example
public interface DoerRepository implements JpaRepository<Long, XEntity> {}

Finalmente, el @Componente, esta es la forma genérica para beans registrados en Spring, es decir, Spring siempre está buscando un bean marcado con @Component para ser registrado, entonces tanto @Service como @Repository son casos especiales de @Component, sin embargo, el caso de uso común para el componente es cuando ¡Está haciendo algo puramente técnico, no para cubrir un caso comercial directo! como formatear fechas o entregar un mecanismo de serialización de solicitudes especiales, etc.

@Component
@Controller
@Repository
@Service
@RestController

Todas estas son anotaciones de StereoType. Son útiles para hacer nuestras clases como frijoles de primavera en el contenedor ioc,