¿Pueden @Component, @Repositoryy las @Serviceanotaciones se 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 @Servicea @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 primavera :

La @Repositoryanotación es un marcador para cualquier clase que cumpla el rol o el estereotipo de un repositorio (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 Traducción de excepciones .

Spring proporciona más anotaciones estereotipo: @Component, @Service, y @Controller. @Componentes un estereotipo genérico para cualquier componente administrado por Spring. @Repository, @Servicey @Controllerson especializaciones de @Componentcasos 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, al anotar con @Repository, @Serviceo @Controller en su lugar, sus clases se adaptan más adecuadamente para procesar por las herramientas o asociarse con aspectos.

Por ejemplo, estas anotaciones de estereotipo son objetivos ideales para puntos de corte. @Repository, @Servicey @Controllertambién puede llevar una semántica adicional en futuras versiones de Spring Framework. Por lo tanto, si elige entre usar @Componento @Servicepara su capa de servicio, @Servicees claramente la mejor opción. De manera similar, como se indicó anteriormente, @Repositoryya es compatible como 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 diferencias menores 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 inyección de dependencia para BeanDefinition, todas estas anotaciones (a saber, @Component, @Service, @Repository, @Controller) son las mismas. Podemos usar uno en lugar de otro y aún así 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.

Lo que es especial acerca de @Component
<context:component-scan> solo escanea@Componenty no busca@Controller,@Servicey@Repositoryen general. Se escanean porque ellos mismos están anotados con@Component.

Basta con echar un vistazo a @Controller, @Servicey @Repositorylas definiciones de anotación:

@Component
public @interface Service {
    ….
}

@Component
public @interface Repository {
    ….
}

@Component
public @interface Controller {
    …
}

Por lo tanto, no está mal decir eso @Controller, @Servicey @Repositoryson tipos especiales de @Componentanotación. <context:component-scan>los recoge y registra sus siguientes clases como beans, como si estuvieran anotados con @Component.

Las anotaciones de tipo especial también se escanean, porque ellas mismas están anotadas con @Componentanotaciones, lo que significa que también son @Components. Si definimos nuestra propia anotación personalizada y la anotamos @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 capturar excepciones específicas de la plataforma y volver a lanzarlas como una de las excepciones unificadas y no verificadas de Spring. Para esto, se nos proporciona PersistenceExceptionTranslationPostProcessorque debemos agregar en el contexto de nuestra aplicación Spring de esta manera:

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

Este postprocesador de beans agrega un asesor a cualquier bean anotado @Repositorypara que se capturen las excepciones específicas de la plataforma y luego se vuelvan a generar como una de las excepciones de acceso a datos no verificadas de Spring.

@Controlador

La @Controlleranotación indica que una clase particular cumple la función de un controlador. La @Controlleranotación actúa como un estereotipo para la clase anotada, indicando su papel.

¿Qué tiene de especial @Controller?

No podemos cambiar esta anotación con ninguna otra similar @Serviceo @Repository, aunque parezcan iguales. El despachador escanea las clases anotadas @Controllery detecta métodos anotados con @RequestMappinganotaciones dentro de ellas. Podemos utilizar @RequestMappingsobre / en sólo aquellos métodos cuyas clases están anotados con @Controllery será NO trabajar con @Component, @Service, @Repositoryetc ...

_{Nota: Si una clase ya está registrado como un bean a través de cualquier método alternativo, al igual que a través @Beano por medio de @Component, @Serviceetc ... anotaciones, a continuación, @RequestMappingse pueden tomar si la clase también se anota con @RequestMappinganotación. Pero ese es un escenario diferente.}

@Servicio

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

¿Qué tiene de especial @Service?

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

¿Qué más?

Similar a lo anterior, en el futuro Spring puede agregar funcionalidades especiales para @Service, @Controllery en @Repositorybase a 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 grano de primavera. @Service, @Repositoryy @Controllerestán especializados @Components. Puede elegir realizar acciones específicas con ellos. Por ejemplo:

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

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

Una cosa que @Componentofrece 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 {..}

Por lo tanto, todas las clases anotadas @ScheduledJobson frijoles de primavera y, además, están registradas como trabajos de cuarzo. Solo tiene que proporcionar un código que maneje la anotación específica.

@Component es equivalente a

<bean>

@Service, @Controller, @Repository = {@Component + alguna funcionalidad más especial}

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 solo hacen cosas como enviar, reenviar, llamar a métodos de servicio, etc.
• Servicio Hold Business Logic, cálculos, etc.
• Los repositorios 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 solo desea supervisar la actividad de la capa DAO. Escribirás una clase de Aspecto (clase A) que hace un registro antes y después de que se invoque cada método de tu DAO, puedes hacerlo usando AOP ya que tienes tres capas distintas y no están mezcladas.

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

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

Lo anterior 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 estereotipo que se utilizan para:

@Controller:donde la asignación de su solicitud desde la página de presentación finaliza, es decir, la capa de presentación no irá a ningún otro archivo, va directamente a la @Controllerclase y comprueba la ruta solicitada en@RequestMapping anotación que se escribe 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 (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 repositorio.

@Component - Anote sus 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 candidatos para la detección automática cuando se utiliza la configuración basada en anotaciones y el escaneo de classpath.

También se puede considerar que otras anotaciones a 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.

Spring 2.5 presenta otras anotaciones de estereotipo: @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 estereotipo son objetivos ideales para 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. Así, 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 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, @Repositoryson todos iguales. Todos ellos se extienden @Component.

Del código fuente de Spring:

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

Podemos utilizar directamente @Componentpara todas y cada grano, 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 Servlet Dispatcher, desde donde pasa la solicitud al controlador en particular utilizando el valor de@RequestMapping anotación.
2. @Service-> Las clases anotadas con esto, están destinadas a manipular los datos que recibimos del cliente o que obtenemos de la base de datos. Toda la manipulación con datos debe 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 únicamente a operaciones CRUD (crear, recuperar, actualizar, eliminar). Si se requiere alguna manipulación, los datos deben enviarse y devolverse a la capa @Service.

Si intercambiamos su lugar (uso @Repositoryen lugar de @Controller), nuestra aplicación funcionará bien.

El propósito principal de usar tres diferentes @annotationses proporcionar una mejor Modularidad a la aplicación Enterprise.

El uso @Servicey las @Repositoryanotaciones son importantes desde la perspectiva de la conexión de la base de datos.

1. Úselo @Servicepara todo su tipo de servicio web de conexiones de base de datos
2. Úselo @Repositorypara todas sus conexiones de DB de proceso almacenadas

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

@Repository @Service y @Controller sirven como especialización de @Component para un uso más específico sobre la base de que puede reemplazar @Service a @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 de tipo estéreo de tipo 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 consiste en algo de lógica, pero no dice si una clase que contiene una lógica específica de negocios o persistencia o controlador, por lo que no usamos directamente esta anotación @Component
• Si agregamos la anotación @Service, indica que un rol de clase consiste en la lógica empresarial
• Si agregamos @Repository en la parte superior de la clase, entonces indica que una clase 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 agreguemos la anotación @Serviceor @Repositroyo @Controllerpor defecto, la @Componentanotación va a existir en la parte superior de la clase

Primavera ofrece cuatro tipos diferentes de anotaciones de escaneo de componentes de automóviles, que son @Component, @Service, @Repositoryy@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 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: Debe usar esta anotación dentro de la capa de persistencia, esto actúa como repositorio de base de datos.

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

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

En referencia a JSR-330, que ahora es compatible con spring, solo puede usar @Namedpara definir un bean (de alguna manera @Named=@Component). Así que de acuerdo a esta norma, parece que no hay empleo para definir estereotipos (como @Repository, @Service, @Controller) en las categorías judías.

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

1. Ayuda a los desarrolladores a definir una mejor categoría para los competentes. Esta categorización puede ser útil en algunos casos. (Por ejemplo, cuando está usando aspect-oriented, estos pueden ser un buen candidato parapointcuts )
2. @Repository la anotación agregará alguna 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, @RequestMappingsolo se puede agregar a las clases que están anotadas por @Controller.

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

No hay ninguna diferencia entre @Component, @Service, @Controller, @Repository. @Componentes 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 componentes de la capa de servicio: @Service
• Para representar los componentes de la capa de presentación: @Controller
• o de lo contrario puede utilizar @Componentpara todos ellos.

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

En Spring 4, última versión:

La anotación @Repository es un marcador para cualquier clase que cumpla el rol o el estereotipo de un repositorio (también conocido como Data Access Object 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 estereotipo: @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 estereotipo son objetivos ideales para puntos de corte. También es posible que @Repository, @Service y @Controller puedan llevar una semántica adicional en futuras versiones de Spring Framework. Así, 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 marcador para la traducción automática de excepciones en su capa de persistencia.

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

@Repository : anota una clase @Repository, le dice a Hibernate que es una clase DAO y la trata como una clase DAO. Significa que las excepciones no marcadas (lanzadas desde los métodos DAO) son elegibles para la traducción a Spring DataAccessException.

@Service : Esto le dice a Hibernate que es una clase de Servicio donde tendrá @Transactionaletc. Anotaciones de la capa de Servicio, por lo que hibernate lo trata como un componente del Servicio.

Además @Servicees avance de @Component. Suponga que el nombre de la clase del bean es CustomerService, ya que no eligió la forma de configuración del bean XML, por lo que anotó el bean con el @Componentfin de indicarlo como un Bean. Entonces, al obtener el objeto bean CustomerService cust = (CustomerService)context.getBean("customerService");Por defecto, Spring minúscula el primer carácter del componente, desde 'CustomerService' hasta 'customerService'. Y puede recuperar este componente con el nombre 'customerService'. Pero si usa una @Serviceanotación para la clase de bean, puede proporcionar un nombre de bean específico

@Service("AAA")
public class CustomerService{

y puedes obtener el objeto bean por

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

@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 verificadas de las clases DAO

@ServiceEs 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 otras anotaciones similares @RequestMappingy todas esas

Aquí hay más detalles

A @Servicepara citar la 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 está sola en el modelo, sin estado encapsulado". También puede indicar que una clase es una "Fachada de servicios comerciales" (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 reducir su semántica y usarla según corresponda.

Si nos fijamos en el diseño impulsado por dominio de Eric Evans,

Un SERVICIO es una operación que se ofrece como una interfaz que está sola en el modelo, sin un estado encapsulado, 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 las ENTIDADES y los OBJETOS DE VALOR, se define únicamente en términos de lo que puede hacer por un cliente. Un SERVICIO tiende a ser nombrado para una actividad, en lugar de una entidad, un verbo en lugar de un sustantivo. Un SERVICIO aún puede tener una definición abstracta e intencional; simplemente tiene un sabor diferente al de la definición de un objeto. Un SERVICIO aún debe tener una responsabilidad definida, y esa responsabilidad y la interfaz que lo cumple deben definirse como parte del modelo de dominio. Los nombres de las operaciones deben provenir de la LENGUA UBIQUITA o introducirse en ella. Los parámetros y resultados deben ser objetos de dominio. Los SERVICIOS deben usarse con prudencia y no permitir que despojen a las ENTIDADES y los 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. Declarado 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. un SERVICIO forma parte natural de un DISEÑO IMPULSADO POR MODELO. Declarado 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. un SERVICIO forma parte natural de un DISEÑO IMPULSADO POR MODELO. Declarado 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 Repositorysegún Eric Evans,

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

Las respuestas lo suficientemente buenas están aquí para explicar las anotaciones de cuál es la diferencia entre los componentes del 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 la @Controllercual agrega @Controllery @ResponseBodyanota automáticamente. así que no tenemos que agregar @ResponseBodya nuestros métodos de mapeo. Eso significa que @ResponseBodyestá activo por defecto.
• Si usa @RestControllerno puede devolver una vista (Al usar Viewresolveren Spring / Spring-Boot)
• @RestControllertambién convierte la respuesta a JSON/XML automaticallycomo @ResponseBodyhace que los objetos devueltos se conviertan en algo que podría estar en el cuerpo,e.g. JSON or XML

@Controller

• @Controllerse usa para marcar clases como Spring MVC Controller. Esta anotación es solo una versión especializada @Componenty 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 mas detallada

El repositorio y el servicio son elementos secundarios de la anotación de componentes . Entonces, todos ellos son Componente . El repositorio y el servicio solo lo expanden. ¿Cómo exactamente? El servicio solo tiene una diferencia ideológica: lo usamos para servicios. El repositorio tiene un controlador de excepciones particular.

Explicación de los estereotipos:

• @Service- Anote todas sus clases de servicio con @Service. Esta capa conoce la unidad de trabajo. Toda su lógica de negocios estará en clases de servicio. En general, los métodos de la capa de servicio están cubiertos por la transacción. Puede realizar múltiples llamadas DAO desde el método de servicio, si una transacción falla, todas las transacciones deberían revertirse.
• @Repository- Anote todas sus clases de 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 a sus clases usando la anotación @Autowired.

@Component es un estereotipo genérico para cualquier componente administrado por Spring. @Repository, @Servicey @Controllerson especializaciones de @Componentcasos de uso más específicos, por ejemplo, en las capas de persistencia, servicio y presentación, respectivamente.

Originalmente respondido aquí .

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

@Component: genérico y se puede usar en todas las aplicaciones.
@Service: anota clases en el nivel de capa de servicio.
@Controller: anota las clases a nivel de las capas de presentación, que se usan 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 (uso para manejar los Frijoles de dominio)

En Spring Framework proporciona algún tipo especial de anotaciones, llamadas anotaciones de estereotipo. 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>al archivo xxx-servlet.xml, spring creará automáticamente el objeto de esas clases que se anotan con la anotación anterior durante la fase de creación / carga de contexto.

@Component` @ Repository` @ Service` @Controller`

@Componentes un estereotipo genérico para los componentes administrados por la primavera @Repository, @Servicey @Controllerson @Componentespecializaciones para más usos específicos:

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

¿Por qué utilizar @Repository, @Service, @Controllersobre@Component ? Podemos marcar nuestras clases de componentes con @Component, pero si en su lugar 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 @Repositorytiene una mejor traducción y manejo legible de errores con org.springframework.dao.DataAccessException. Ideal para implementar componentes que acceden a datos (DataAccessObject o DAO).

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

Una clase anotada con @Servicejuega un papel en los servicios de lógica de negocios, por ejemplo, el patrón Facade para DAO Manager (Facade) y el manejo de transacciones

Las respuestas presentadas aquí son en gran medida técnicamente correctas, pero a pesar de que la lista de respuestas es larga y esto 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 y aprenda algo valioso de eso. No es que el resto de las respuestas estén equivocadas, es solo que no están correctas. Y, para detener a las hordas de trolls, sí, sé que técnicamente estas anotaciones son efectivamente lo mismo y más intercambiables incluso hasta la primavera 5. Ahora, para la respuesta correcta:

Estas tres anotaciones son cosas completamente diferentes y no son intercambiables. Puedes decir eso porque hay tres en lugar de solo uno. No están destinados a ser intercambiables, solo 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 se lee 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 leen 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 efectivamente tan lejos en el futuro. Por lo tanto, es vital que usemos el lenguaje más claro, más eficiente, correcto y comunicativo disponible para nosotros.

Por ejemplo, es vital que @Repositoryse use cuando escribimos un repositorio, en lugar de hacerlo @Component. Esta última es una elección de anotación muy pobre para un repositorio porque no indica que estamos viendo un repositorio. Podemos suponer que un repositorio es también un spring-bean, pero no que un componente sea un repositorio. Con@Repository nosotros estamos siendo claros y específicos en nuestro idioma. Estamos afirmando claramente que este es un repositorio. Con@Componentdejamos que el lector decida qué tipo de componente están leyendo, y tendrán 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 no un repositorio, y habríamos sido parcialmente responsables de este error porque nosotros, que sabíamos muy bien que se trata de un repositorio, no fuimos específicos en nuestro idioma y comunicar efectivamente nuestra intención.

No entraré en los otros ejemplos, pero declararé lo más claramente posible: estas anotaciones son cosas completamente diferentes y deben usarse de manera apropiada, según su intención. @Repositoryes para repositorios de almacenamiento y ninguna otra anotación es correcta. @Servicees para servicios y ninguna otra anotación es correcta. @Componentes 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 pasar sus pruebas, pero estaría mal y pensaría menos de usted (profesionalmente) si hiciera esto.

Hay ejemplos de esto durante la primavera (y la programación en general). No debe usarlo @Controlleral escribir una API REST, porque @RestControllerestá disponible. No debe usar @RequestMappingcuando @GetMappinges una alternativa válida. Etc. Etc. Etc. Debe elegir el lenguaje exacto y correcto más específico posible para comunicar su intención a sus lectores, de lo contrario, está introduciendo riesgos en su sistema, y ​​el riesgo tiene un costo.

Para simplificar esta ilustración, consideremos el tecnicismo por caso de uso. Estas anotaciones se usan para inyectarse y, como dije literalmente " Solía ​​inyectarse ", es decir, si sabe cómo usar la inyección de dependencia "DI" y usted debería, entonces siempre buscará estas anotaciones, y al anotar las clases con estos tipos estéreo , está informando al contenedor DI para escanearlos para que estén listos para la inyección en otros lugares, este es el objetivo práctico.

Ahora pasemos a cada uno; primero @Service , si está creando algo de lógica para un caso de negocios específico, necesita separarlo en un lugar que contendrá su lógica de negocios, este servicio es de Clase normal o puede usarlo como interfaz si lo desea, y está escrito como esta

@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, @Repository es una interfaz que aplica la implementación para el patrón de diseño de Repository Pattern Repository , generalmente se usa cuando se trata de algún almacén de datos o base de datos, y encontrará que contiene múltiples implementación lista para que usted maneje las operaciones de la base de datos; puede ser CrudRepository , JpaRepository , etc.

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

Finalmente , @Component , esta es la forma genérica para los beans registrados en Spring, esa primavera siempre está buscando frijoles marcados con @Component para registrarse, luego @Service y @Repository son casos especiales de @Component, sin embargo, el caso de uso común ¡el componente es cuando estás haciendo algo puramente técnico, no para cubrir el caso comercial directo! como formatear fechas o entregar mecanismos de serialización de solicitudes especiales, etc.

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

@Service , extiende la anotación @Component y solo tiene una diferencia de nomenclatura.

@Repository : extiende la anotación @Component y traduce todas las excepciones de la base de datos a DataAccessException .

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

@Component
@Controller
@Repository
@Service
@RestController

Estas son todas las anotaciones StereoType. Estas son útiles para hacer nuestras clases como frijoles de primavera en el contenedor ioc,