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




mvc que (21)

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

@Controller: donde se realiza la asignación de la solicitud 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 verifica la ruta solicitada en la anotación @RequestMapping que se escribió antes del 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, por lo que 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 (capa de acceso a datos) de la aplicación que se utiliza para obtener datos de la base de datos. Es decir, todas las operaciones relacionadas con la base de datos son realizadas por el repositorio.

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

Indica que una clase anotada es un " component ". Estas clases se consideran como candidatas 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 de nivel de clase identifican un componente, típicamente un tipo especial de componente: por ejemplo, la anotación @Repository o la anotación @Aspect de AspectJ.

component

¿ @Component pueden usar indistintamente las anotaciones @Component , @Repository y @Service 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 , ¿se seguirá comportando de la misma manera?

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


No hay diferencia entre @ Componente, @ Servicio, @ Controlador, @ Repositorio. @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 los componentes de la capa de servicio, los componentes de la capa de persistencia y los componentes de la capa de presentación. Así que para diferenciarlos, la gente de Spring también ha hecho las otras tres anotaciones.

Para representar los componentes de la capa de persistencia: @Repository

Para representar los componentes de la capa de servicio: @Servicio

Para representar los componentes de la capa de presentación: @Controller

o bien puede usar @Component para todos ellos.


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

Desde el código fuente de Spring:

Indica que una clase anotada es un "componente". Estas clases se consideran como candidatas para la detección automática cuando se utiliza 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 mantenimiento 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 Displeter Servlet, desde donde pasa la solicitud al controlador en particular utilizando el valor de la anotación @RequestMapping.

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 estar restringida únicamente a las operaciones CRUD (crear, recuperar, actualizar, eliminar). 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 propósito principal del uso de tres @notaciones diferentes es proporcionar una mejor modularidad a la aplicación Enterprise.


@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 ofrece la función de convertir todas las excepciones sin marcar 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 reconoce el MVC del bean y permite el uso de anotaciones adicionales como @RequestMapping y todo lo demás.

Aquí hay más details


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 y la inyección de dependencia para BeanDefinition todas estas anotaciones (es decir, @Component, @Service, @Repository, @Controller) son las mismas. 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 escanea @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 las definiciones de anotación @Controller , @Service y @Repository :

@Component
public @interface Service {
    ….
}

@Component
public @interface Repository {
    ….
}

@Component
public @interface Controller {
    …
}

Por lo tanto, no es incorrecto decir que @Controller , @Service y @Repository son tipos especiales de anotación @Component . <context:component-scan> recoge y registra sus siguientes clases como beans, como si estuvieran anotados con @Component .

Se escanean porque ellos mismos se anotan con la anotación @Component . Si definimos nuestra propia anotación personalizada y la anotamos con @Component , también se analizará 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 se trata de una configuración basada en anotación , el trabajo de @Repository es capturar excepciones específicas de la plataforma y volver a lanzarlas como una de las excepciones no verificadas unificadas de Spring. Y para esto, contamos con PersistenceExceptionTranslationPostProcessor , que estamos obligados a agregar en el contexto de nuestra aplicación de Spring de esta manera:

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

Este procesador posterior de bean agrega un asesor a cualquier bean anotado con @Repository para que las excepciones específicas de la plataforma se capturen y luego se vuelvan a generar como una de las excepciones de acceso a datos no comprobadas de Spring.

@Controlador

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

¿Qué tiene de especial @Controller?

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

@Servicio

@Services mantienen la lógica de negocios y el método 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 de negocios, no hay una especialidad notable que proporcione esta anotación, pero quién sabe, la primavera puede agregar algo excepcional adicional en el futuro.

¿Qué más?

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


Un @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 estado encapsulado". También puede indicar que una clase es un "Business Service Facade" (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 restringir su semántica y usar según sea apropiado.

Si nos fijamos en el diseño impulsado por el dominio por eric evans,

Un SERVICIO es una operación que se ofrece como una interfaz independiente del modelo, sin encapsular el estado, como lo hacen ENTIDADES y 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 puramente 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 todavía puede tener una definición abstracta e intencional; solo tiene un sabor diferente a la definición de un objeto. Un SERVICIO aún 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 IDIOMA UBIQUITOSO o introducirse en él. Los parámetros y resultados deben ser objetos de dominio. Los SERVICIOS deben usarse con prudencia y no se les debe permitir despojar a las ENTIDADES y OBJETOS DE VALOR de todo su comportamiento. Pero cuando una operación es realmente un concepto de dominio importante, un SERVICIO forma parte natural de un DISEÑO MODELO CON CONDUCCIÓN. Declarada en el modelo como SERVICIO, en lugar de como un objeto falso que no representa nada, la operación independiente no engañará a nadie.

y un Repository según Eric Evans,

Un REPOSITORIO representa todos los objetos de un determinado 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 cohesivo de responsabilidades para proporcionar acceso a las raíces de AGREGADOS desde el comienzo del ciclo de vida hasta el final.


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

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

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 @Service la @Service o @Repositroy o @Controller por defecto, la anotación @Component va a existir en la parte superior de la clase

@Componente : usted anota una clase @Componente, le dice a hibernar que es un Bean.

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

@Servicio : Esto le dice a Hibernate que es una clase de servicio donde tendrá @Transactional, etc. Anotaciones de capa de servicio, por lo que Hibernate lo trata como un componente de servicio.

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

@Service("AAA")
public class CustomerService{

y usted puede obtener el objeto de frijol por

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

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 procesarlas con herramientas o asociarlas con aspectos. Por ejemplo, estas anotaciones de estereotipos son objetivos ideales para cortes de puntos. Por supuesto, también es posible que @Repository, @Service y @Controller puedan llevar semánticas adicionales en futuras versiones de Spring Framework. Por lo tanto, si toma 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: - Documentación Spring - Escaneo de Classpath, componentes administrados y configuraciones de escritura usando Java


@component
@controller
@Repository
@service
@RestController

Estas son todas las anotaciones de StereoType. Si colocamos @controller encima de la clase. No se convertirá en una clase de controlador en función de las diferentes capas (componentes) que podemos anotar con estas anotaciones, pero el compilador no hará nada al respecto solo para el propósito de la comprensión del desarrollador, podemos elegir en función de los componentes en que anotaciones tenemos que escribir.


Podemos responder esto de acuerdo al estándar de java.

Con referencia a JSR-330 , que ahora es compatible con Spring, solo puede usar @Named para definir un bean (Somehow @[email protected] ). Entonces, de acuerdo con este estándar, parece que no sirve de nada definir estereotipos (como @Repository , @Service , @Controller ) para los beans de categorías.

Pero use estas anotaciones diferentes en diferentes para el uso específico, por ejemplo:

  1. Ayudar a los desarrolladores a definir una mejor categoría para los competentes. Esta categorización puede ser útil en algunos casos. (Por ejemplo, cuando utiliza aspect-oriented , estos pueden ser un buen candidato para los pointcuts de pointcuts )
  2. @Repository anotación de @Repository 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, @RequestMapping solo se puede agregar a las clases 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 gestionado de Spring.

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

@Componente en primavera


@Repository @Service y @Controller sirven como especialización de @Component para un uso más específico sobre esa base, 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.

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

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

@Controller : la clase anotada indica que es un componente del controlador y se utiliza 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 base de datos.

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


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

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

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


@Component es equivalente a

<bean>

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

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

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

  • Los controladores solo hacen cosas como envío, reenvío, métodos de servicio de llamadas, etc.
  • Servicio Hold Business Logic, Cálculos, etc.
  • Los repositorios son los DAO (objetos de acceso a datos), acceden directamente a la base de datos.

Ahora puede preguntar por qué separarlos: (Supongo que conoce la Programación Orientada a Aspectos de AOP)

Digamos que desea supervisar la actividad de la capa DAO solamente. Escribirá una clase de Aspecto (clase A) que hace un registro antes y después de invocar cada método de su DAO, puede hacerlo usando AOP ya que tiene tres Capas distintas y no está mezclado.

Por lo tanto, puede realizar 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 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á un código de despacho, lógica de negocios y acceso a la base de datos todo mezclado, ¡así que es un código sucio!

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


En primavera 4, última versión:

La anotación @Repository es un marcador para cualquier clase que cumpla la función o el estereotipo de un repositorio (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 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 para asociarse con aspectos. Por ejemplo, estas anotaciones de estereotipos son objetivos ideales para cortes de puntos. También es posible que @Repository, @Service y @Controller puedan llevar 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 marcador para la traducción automática de excepciones en su capa de persistencia.


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

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

  • @Repositivo para la persistencia
  • @Servicio de servicios y transacciones.
  • @Controller para controladores MVC

¿Por qué usar @Repository, @Service, @Controller sobre @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 manejo de errores legibles con org.springframework.dao.DataAccessException. Ideal para implementar componentes que acceden a datos (DataAccessObject o DAO).

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

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


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

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

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

Una cosa que ofrece @Component es que puede anotar otras anotaciones y luego usarlas de la misma forma que @Service .

Por ejemplo recientemente hice:

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

Así que todas las clases anotadas con @ScheduledJob son frijoles de primavera y además están registrados como trabajos de cuarzo. Solo tienes que proporcionar el código que maneja la anotación específica.


En Spring Framework se proporcionan algunos tipos especiales de anotaciones, denominadas anotaciones de estereotipos. 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 anteriores son especiales porque cuando agregamos <context:component-scan>al archivo xxx-servlet.xml, Spring creará automáticamente el objeto de aquellas clases que se anotan con la anotación anterior durante la fase de creación / carga de contexto.


JPA es una especificación que implementa en su capa de datos para realizar operaciones db, asignaciones O y otras tareas requeridas.

Como solo es una especificación , necesita una herramienta para implementarla. Esa herramienta puede ser Hibernate, TopLink, iBatis, spring-data, etc.

No necesariamente requiere JPA si está usando Hibernate en su capa de datos. Pero si usa la especificación JPA para Hibernate, entonces será más fácil cambiar a otras herramientas ORM como iBatis, TopLink en el futuro, porque la especificación también es común para otros.

* ( si recuerdas, import javax.persistence.*; cuando usas anotaciones para el mapeo OR (como @Id, @Column, @GeneratedValue, etc.) en Hibernate, ahí es donde usas JPA bajo Hibernate, puedes usar @Query de JPA y otras características también )





java spring spring-mvc annotations