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




tipos de anotaciones spring (16)

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

https://code.i-harness.com

¿ @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?


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


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.


De la documentación de primavera :

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

Spring 2.5 introduce otras 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 @Repository 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.

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.

┌────────────┬─────────────────────────────────────────────────────┐
│ 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)      │
└────────────┴─────────────────────────────────────────────────────┘

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


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.


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.


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 .

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.


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.


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

@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


@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");

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

@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


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.





annotations