web-dev-qa-db-fra.com

Quelle est la différence entre les annotations @Component, @Repository & @Service au printemps?

Les annotations @Component, @Repository et @Service peuvent-elles être utilisées indifféremment dans Spring ou fournissent-elles une fonctionnalité particulière en plus de servir de dispositif de notation?

En d'autres termes, si j'ai une classe de service et que je change l'annotation de @Service en @Component, le comportement sera-t-il toujours le même?

Ou bien l'annotation influence-t-elle également le comportement et la fonctionnalité de la classe?

javaspringspring-mvcannotations
1913
Colin McCree

De documentation de printemps :

Dans Spring 2.0 et les versions ultérieures, l'annotation @Repository est un marqueur pour toute classe remplissant le rôle ou le stéréotype (également appelé objet d'accès à les données ou DAO) d'un référentiel. Parmi les utilisations de ce marqueur figure la traduction automatique des exceptions.

Spring 2.5 introduit d'autres annotations de stéréotypes: @Component, @Service et @Controller. @Component est un stéréotype générique pour tout composant géré par Spring. @Repository, @Service et @Controller sont des spécialisations de @Component pour des cas d'utilisation plus spécifiques, par exemple, dans les couches de persistance, de service et de présentation, respectivement.

Par conséquent, vous pouvez annoter vos classes de composants avec @Component, mais en les annotant avec @Repository, @Service ou @Controller, vos classes sont mieux adaptées au traitement par des outils. ou en association avec des aspects. Par exemple, ces annotations de stéréotypes sont des cibles idéales pour les découpes en points.

Ainsi, si vous choisissez d'utiliser @Component ou @Service pour votre couche de service, @Service est clairement le meilleur choix. De même, comme indiqué ci-dessus, @Repository est déjà pris en charge en tant que marqueur pour la traduction automatique des exceptions dans votre couche de persistance.

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

Comme de nombreuses réponses indiquent déjà à quoi servent ces annotations, nous nous concentrerons ici sur quelques différences mineures entre elles.

D'abord le similarité

Le premier point à souligner est que en ce qui concerne l'analyse par détection automatique et l'injection de dépendance pour BeanDefinition toutes ces annotations (à savoir, @Component, @Service, @Repository, @Controller) sont identiques. Nous pouvons utiliser l'un à la place de l'autre et nous pouvons toujours nous débrouiller.

Différences entre @Component, @Repository, @Controller et @Service

@ Composant

Il s'agit d'une annotation stéréotypée à usage général indiquant que la classe est un composant de ressort.

Quelle est la particularité de @Component
<context:component-scan> analyse uniquement @Component et ne recherche pas @Controller, @Service et @Repository en général. Ils sont scannés car ils sont eux-mêmes annotés avec @Component.

Il suffit de regarder les définitions d'annotation @Controller, @Service et @Repository:

@Component
public @interface Service {
    ….
}


@Component
public @interface Repository {
    ….
}


@Component
public @interface Controller {
    …
}

Il n’est donc pas faux de dire que @Controller, @Service et @Repository sont des types spéciaux d’annotation @Component. <context:component-scan> les récupère et enregistre leurs classes suivantes sous forme de haricots, comme si elles étaient annotées avec @Component.

Les annotations de type spécial sont également analysées, car elles-mêmes sont annotées avec l'annotation @Component, ce qui signifie qu'elles sont également @Components. Si nous définissons notre propre annotation personnalisée et l'annotons avec @Component, elle sera également analysée avec <context:component-scan>.

@ Repository

Cela indique que la classe définit un référentiel de données.

Quelle est la particularité de @Repository?

En plus de souligner qu'il s'agit d'une configuration basée sur des annotations , @Repository consiste à intercepter des exceptions spécifiques à une plate-forme et à les renvoyer sous la forme suivante: une des exceptions unifiées non contrôlées de Spring. Pour cela, nous avons fourni PersistenceExceptionTranslationPostProcessor, que nous devons ajouter dans notre contexte d’application Spring comme ceci:

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

Ce post-processeur de bean ajoute un conseiller à tout bean annoté avec @Repository de sorte que toutes les exceptions spécifiques à la plate-forme soient interceptées puis rediffusées en tant qu’une des exceptions d’accès aux données non vérifiées de Spring.

@ Controller

L'annotation @Controller indique qu'une classe particulière joue le rôle de contrôleur. L'annotation @Controller joue le rôle de stéréotype pour la classe annotée, indiquant son rôle.

Quelle est la particularité de @Controller?

Nous ne pouvons pas changer cette annotation avec une autre comme @Service ou @Repository, même si elles ont l’air identique. Le répartiteur analyse les classes annotées avec @Controller et détecte les méthodes annotées avec @RequestMapping annotations en leur sein. Nous pouvons utiliser @RequestMapping sur/dans uniquement les méthodes dont les classes sont annotées avec @Controller et cela fonctionnera PAS fonctionnera avec @Component, @Service , @Repository etc ...

Remarque: Si une classe est déjà enregistrée en tant que bean via une autre méthode, comme par le biais de @Bean ou de @Component, @Service etc ... , alors @RequestMapping peut être sélectionné si la classe est également annotée avec @RequestMapping annotation. Mais c'est un scénario différent.

@ Service

Les beans @Service contiennent la logique métier et les méthodes d'appel dans la couche de référentiel.

Quelle est la particularité de @Service?

Hormis le fait qu’elle sert à indiquer, qu’elle tient la logique métier, il n’y a rien d’autre à remarquer dans cette annotation; mais qui sait, le printemps pourrait ajouter des éléments exceptionnels à l’avenir.

Quoi d'autre?

Semblable à ce qui précède, à l'avenir, Spring pourrait ajouter des fonctionnalités spéciales pour @Service, @Controller et @Repository en fonction de leurs conventions de superposition. Par conséquent, il est toujours bon de respecter la convention et de l’utiliser en conformité avec les calques.

685
Raman Sahasi

Ils sont presque les mêmes - tous signifient que la classe est un haricot printanier. @Service, @Repository et @Controller sont spécialisés @Components. Vous pouvez choisir d'effectuer des actions spécifiques avec eux. Par exemple:

  • Les haricots @Controller sont utilisés par spring-mvc
  • Les beans @Repository sont éligibles pour la conversion des exceptions de persistance

Une autre chose est que vous désignez sémantiquement les composants dans différentes couches.

Une chose que @Component offre est que vous pouvez annoter d’autres annotations avec elle, puis les utiliser de la même manière que @Service.

Par exemple récemment j'ai fait:

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

Ainsi, toutes les classes annotées avec @ScheduledJob sont des haricots de printemps et sont en outre enregistrées en tant que travaux au quartz. Vous devez simplement fournir un code qui gère l'annotation spécifique.

419
Bozho

@Component est équivalent à

<bean>

@ Service, @Controller, @Repository = {@Component + autres fonctionnalités spéciales}

Cela signifie que Service, le contrôleur et le référentiel sont fonctionnellement identiques.

Les trois annotations servent à séparer "Calques" dans votre application,

  • Les contrôleurs ne font que des tâches telles que la répartition, le transfert, les méthodes de service d’appel, etc.
  • Service Tenir la logique d’entreprise, les calculs, etc.
  • Les référentiels sont les DAO (Data Access Objects), ils accèdent directement à la base de données.

Maintenant, vous pouvez demander pourquoi les séparer: (je suppose que vous connaissez la programmation orientée AOP)

Supposons que vous souhaitiez surveiller uniquement l'activité de la couche DAO. Vous allez écrire une classe Aspect (une classe) qui effectue une journalisation avant et après chaque méthode de votre DAO, vous pouvez le faire en utilisant AOP, car vous avez trois couches distinctes et ne sont pas mélangées.

Ainsi, vous pouvez enregistrer DAO "autour", "avant" ou "après" les méthodes DAO. Vous pouvez le faire parce que vous aviez un DAO en premier lieu. Ce que vous venez de réaliser est Séparation des préoccupations ou des tâches.

Imaginez s’il n’y avait qu’une seule annotation @Controller, alors ce composant disposera d’une logique d’affectation, de logique commerciale et d’un accès à la base de données, donc du code corrompu!

Le scénario mentionné ci-dessus est très courant. Il existe de nombreux autres cas d'utilisation de la raison pour laquelle trois annotations sont utilisées.

352
Oliver

Au printemps, @Component, @Service, @Controller et @Repository sont des annotations de stéréotypes utilisées pour:

@Controller: où votre demande mappage depuis la page de présentation est terminée La couche de présentation n'ira dans aucun autre fichier. Elle ira directement à la classe @Controller et recherchera le chemin demandé dans l'annotation @RequestMapping qui a écrit avant les appels de méthode, si nécessaire.

@Service: Toute la logique métier est ici, c’est-à-dire les calculs relatifs aux données, et tous. Il demandera @Repository selon la demande de l'utilisateur

@Repository: C'est la couche de persistance (couche d'accès aux données) de l'application qui récupérait les données de la base de données. c'est-à-dire toutes les opérations liées à la base de données sont effectuées par le référentiel

@Component - Annotez vos autres composants (par exemple REST classes de ressources) avec un stéréotype de composant.

Indique qu'une classe annotée est un " composant ". Ces classes sont considérées comme des candidates à la détection automatique lors de l'utilisation de la configuration basée sur des annotations et du balayage des chemins d'accès aux classes.

D'autres annotations au niveau classe peuvent également être considérées comme identifiant un composant, généralement un type de composant spécial: par ex. l'annotation @Repository ou l'annotation @Aspect d'AspectJ.

enter image description here

213
Harshal Patil

Spring 2.5 introduit d'autres annotations de stéréotypes: @Component, @Service et @Controller. @Component sert de stéréotype générique à tout composant géré par Spring; alors que @Repository, @Service et @Controller servent de spécialisations de @Component pour des cas d'utilisation plus spécifiques (par exemple, dans les couches de persistance, de service et de présentation, respectivement). Cela signifie que vous pouvez annoter vos classes de composant avec @Component, mais en les annotant avec @Repository, @Service ou @Controller, vos classes sont mieux adaptées au traitement par des outils ou à l'association avec des aspects. Par exemple, ces annotations de stéréotypes sont des cibles idéales pour les découpes en points. Bien entendu, il est également possible que @Repository, @Service et @Controller comportent une sémantique supplémentaire dans les prochaines versions de Spring Framework. Ainsi, si vous décidez d'utiliser @Component ou @Service pour votre couche de service, @Service est clairement le meilleur choix. De même, comme indiqué ci-dessus, @Repository est déjà pris en charge en tant que marqueur pour la traduction automatique des exceptions dans votre couche de persistance.

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

référence: - Documentation Spring - Analyse des chemins d'accès aux classes, composants gérés et configurations d'écriture utilisant Java

69
Ajit Singh

L'utilisation des annotations @Service et @Repository est importante du point de vue de la connexion à la base de données.

  1. Utilisez @Service pour tous les types de connexions de base de données de votre service Web.
  2. Utilisez @Repository pour toutes vos connexions à la base de données proc stockées.

Si vous n'utilisez pas les annotations appropriées, vous pouvez être confronté à des exceptions de validation remplacées par des transactions d'annulation. Vous verrez des exceptions lors du test de charge de stress lié à l'annulation de transactions JDBC.

45
Das

Techniquement, @Controller, @Service, @Repository sont tous identiques. Chacun d'eux s'étend @Component.

A partir du code source Spring:

Indique qu'une classe annotée est un "composant". Ces classes sont considérées comme des candidates à la détection automatique lors de l'utilisation de la configuration basée sur des annotations et du balayage des chemins d'accès aux classes.

Nous pouvons utiliser directement @Component pour chaque bean, mais pour mieux comprendre et maintenir une grande application, nous utilisons @Controller, @Service, @Repository.

But de chaque annotation:

  1. @Controller -> Les classes annotées avec ceci sont destinées à recevoir une demande du côté client. La première demande parvient au servlet Dispatcher, à partir duquel il transmet la demande au contrôleur particulier en utilisant la valeur de l'annotation @RequestMapping.
  2. @Service -> Les classes annotées avec ceci sont destinées à manipuler les données que nous recevons du client ou que nous extrayons de la base de données. Toutes les manipulations avec les données doivent être effectuées dans cette couche.
  3. @Repository -> Les classes annotées avec cela sont destinées à se connecter avec la base de données. Elle peut également être considérée comme une couche DAO (Data Access Object). Cette couche doit être limitée aux opérations CRUD (création, récupération, mise à jour, suppression) uniquement. Si une manipulation est nécessaire, les données doivent être renvoyées à la couche @Service.

Si nous échangeons leur place (utilisez @Repository à la place de @Controller), notre application fonctionnera correctement.

Le but principal d’utiliser trois @annotations différents est de fournir une meilleure modularité à l’application Enterprise.

32
Yogendra123

@ Repository@ Service et @ Controller servent de spécialisation de @Component pour une utilisation plus spécifique sur cette base, vous pouvez remplacer @Service par @Component. mais dans ce cas, vous perdez la spécialisation.

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.
27
atish shimpi

toutes ces annotations sont du type de type stéréo, la différence entre ces trois annotations est

  • Si nous ajoutons le @Component, il indique alors que le rôle de la classe est une classe de composant, mais qu’il s’agit d’une classe comportant une logique, directement cette annotation @Component
  • Si nous ajoutons une annotation @Service, il indique qu'un rôle de classe consistant en une logique métier
  • Si nous ajoutons @Repository au-dessus de la classe, il indique qu'une classe consistant en une logique de persistance
  • @Component est ici une annotation de base pour les annotations @ Service, @ Repository et @Controller.

par exemple

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
    }
}
  • chaque fois que nous ajoutons l'annotation @Service ou @Repositroy ou @Controller par défaut _ l'annotation @Component va exister au-dessus de la classe
26
Anil Amane

Spring propose quatre types différents d'annotations d'analyse de composant automatique: @Component, @Service, @Repository et @Controller. Techniquement, il n'y a pas de différence entre elles, mais chaque annotation de numérisation de composant automatique doit être utilisée à des fins spéciales et au sein de la couche définie.

@Component: Il s'agit d'une annotation d'analyse élémentaire de composant automatique. Elle indique que la classe annotée est un composant d'analyse automatique.

@Controller: La classe annotée indique qu'il s'agit d'un composant contrôleur, principalement utilisé au niveau de la couche de présentation.

@Service: Cela indique que la classe annotée est un composant de service de la couche de gestion.

@Repository: Vous devez utiliser cette annotation dans la couche de persistance, elle agit comme un référentiel de base de données.

On devrait choisir une forme plus spécialisée de @Component tout en annotant leur classe car cette annotation peut contenir un comportement spécifique à l'avenir.

21
hardeep thakur

Nous pouvons répondre à cette question conformément au Java standard

En référence à JSR-330, qui est maintenant pris en charge par spring, vous ne pouvez utiliser que @Named pour définir un bean (D'une manière ou d'une autre @Named=@Component). Donc, selon cette norme, il semble inutile de définir des stéréotypes (comme @Repository, @Service, @Controller) aux catégories de haricots.

Mais printemps utilisateur ces différentes annotations dans différents pour l'utilisation spécifique, par exemple:

  1. Aidez les développeurs à définir une meilleure catégorie pour les compétents. Cette catégorisation peut devenir utile dans certains cas. (Par exemple, lorsque vous utilisez aspect-oriented, ils peuvent constituer un bon candidat pour pointcuts.)
  2. L'annotation @Repository ajoutera des fonctionnalités à votre bean (une traduction automatique des exceptions vers la couche de persistance de votre bean).
  3. Si vous utilisez spring MVC, le @RequestMapping ne peut être ajouté qu'aux classes annotées par @Controller.
20
Alireza Fattahi

Annotez d'autres composants avec @Component, par exemple REST Classes de ressources.

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

@Component est un stéréotype générique pour tout composant géré par Spring.

@Controller, @Service et @Repository sont des spécialisations de @Component pour des cas d'utilisation spécifiques.

Composant au printemps

"Component Specialization"

18
Anil Nivargi

Même si nous échangeons @Component ou @Repository ou @service

Il se comportera de la même manière, mais l’un des aspects est qu’ils ne pourront pas intercepter une exception spécifique liée à DAO au lieu de Repository si nous utilisons composant ou @ service.

16
Manjush

Au printemps 4, dernière version:

L'annotation @Repository est un marqueur pour toute classe remplissant le rôle ou le stéréotype d'un référentiel (également appelé objet d'accès aux données ou DAO). Parmi les utilisations de ce marqueur, il y a la traduction automatique des exceptions, décrite à la Section 20.2.2, "Traduction des exceptions".

Spring fournit d'autres annotations de stéréotypes: @Component, @Service et @Controller. @Component est un stéréotype générique pour tout composant géré par Spring. @Repository, @Service et @Controller sont des spécialisations de @Component pour des cas d'utilisation plus spécifiques, par exemple, dans les couches de persistance, de service et de présentation, respectivement. Par conséquent, vous pouvez annoter vos classes de composant avec @Component, mais en les annotant avec @Repository, @Service ou @Controller, vos classes sont plus adaptées au traitement par des outils ou à l'association d'aspects. Par exemple, ces annotations de stéréotypes sont des cibles idéales pour les découpes en points. Il est également possible que @Repository, @Service et @Controller comportent une sémantique supplémentaire dans les prochaines versions de Spring Framework. Ainsi, si vous choisissez d'utiliser @Component ou @Service pour votre couche de service, @Service est clairement le meilleur choix. De même, comme indiqué ci-dessus, @Repository est déjà pris en charge en tant que marqueur pour la traduction automatique des exceptions dans votre couche de persistance.

15
Quan Nguyen

@Component est l'annotation générique de niveau supérieur qui rend le bean annoté à analyser et disponible dans le conteneur DI.

@Repository est une annotation spécialisée et apporte la fonction de conversion de toutes les exceptions non contrôlées des classes DAO.

@Service est une annotation spécialisée. il n'apporte aucune nouvelle fonctionnalité à partir de maintenant, mais il clarifie l'intention du haricot

@Controller est une annotation spécialisée qui rend le bean MVC conscient et permet l'utilisation d'annotation supplémentaire telle que @RequestMapping et ainsi de suite.

Voici plus détails

12
Amol Dixit

Il n'y a pas de différence entre @ Component, @ Service, @ Controller, @ Repository. @Component est l'annotation générique représentant le composant de notre MVC. Toutefois, notre application MVC comportera plusieurs composants, tels que des composants de couche de service, des composants de couche de persistance et des composants de couche de présentation. Donc, pour les différencier, les gens du printemps ont également donné les trois autres annotations.

Pour représenter les composants de la couche de persistance: @Repository

Pour représenter les composants de la couche de service: @Service

Pour représenter les composants de la couche de présentation: @Controller

ou bien vous pouvez utiliser @Component pour tous.

12
tech.yenduri

Un @Service pour citer la documentation de printemps,

Indique qu'une classe annotée est un "service", défini à l'origine par Domain-Driven Design (Evans, 2003) en tant que "opération proposée comme une interface autonome dans le modèle, sans état encapsulé." = Peut également indiquer qu’une classe est une "façade de service métier" (au sens des modèles J2EE principaux), ou quelque chose de similaire. Cette annotation est un stéréotype à usage général et les équipes individuelles peuvent affiner leur sémantique et l'utiliser de manière appropriée.

Si vous regardez la conception pilotée par le domaine par Eric Evans,

Un SERVICE est une opération proposée comme une interface autonome dans le modèle, sans état d'encapsulation, comme le font ENTITIES et VALUE OBJECTS. Les SERVICES constituent un modèle courant dans les cadres techniques, mais ils peuvent également s'appliquer à la couche de domaine. Le service de noms met l'accent sur la relation avec d'autres objets. Contrairement à ENTITIES et à VALUE OBJECTS, il est défini uniquement en fonction de ce qu’il peut faire pour un client. Un SERVICE a tendance à être nommé pour une activité plutôt que comme une entité, un verbe plutôt qu'un nom. Un SERVICE peut toujours avoir une définition abstraite et intentionnelle; cela a simplement une saveur différente de la définition d'un objet. Un SERVICE doit toujours avoir une responsabilité définie, et cette responsabilité et l'interface qui la remplit doivent être définies comme faisant partie du modèle de domaine. Les noms d'opération doivent provenir de la langue UBIQUITOUS ou y être introduits. Les paramètres et les résultats doivent être des objets de domaine. SERVICES doit être utilisé judicieusement et ne pas être autorisé à dépouiller les ENTITÉS et les OBJETS DE VALEUR de tout leur comportement. Mais lorsqu'une opération est en réalité un concept de domaine important, un SERVICE fait naturellement partie d'un CONCEPTION AXÉE SUR LE MODÈLE. Déclarée dans le modèle comme un SERVICE plutôt que comme un objet factice qui ne représente en réalité rien, l'opération autonome n'induira personne en erreur.

et un Repository selon Eric Evans,

Un REPOSITORY représente tous les objets d'un certain type sous la forme d'un ensemble conceptuel (généralement émulé). Il agit comme une collection, sauf avec une capacité d'interrogation plus élaborée. Les objets du type approprié sont ajoutés et supprimés et la machine située derrière le REPOSITORY les insère ou les supprime de la base de données. Cette définition rassemble un ensemble cohérent de responsabilités pour fournir un accès aux racines des AGREGATS du début de leur cycle de vie à la fin.

10
Bharath

@ Component: vous annotez une classe @Component, elle indique à Hibernate qu'il s'agit d'un bean.

@ Repository: vous annotez une classe @Repository, il indique à Hibernate qu'il s'agit d'une classe DAO et la traite comme une classe DAO. Cela signifie que les exceptions non vérifiées (générées par les méthodes DAO) sont éligibles pour la conversion en Spring DataAccessException.

@ Service: Ceci indique à Hibernate qu'il s'agit d'une classe de service dans laquelle vous aurez les annotations @Transactional, etc. de la couche de service, afin que hibernate le traite comme un composant de service.

De plus, @Service est une avance de @Component. Supposons que le nom de la classe de bean est CustomerService, étant donné que vous n'avez pas choisi la méthode de configuration de bean XML, vous avez donc annoté le bean avec @Component pour l'indiquer en tant que bean. Ainsi, lors de l’obtention de l’objet bean CustomerService cust = (CustomerService)context.getBean("customerService");, Spring active par défaut le premier caractère du composant, de "CustomerService" à "customerService". Et vous pouvez récupérer ce composant avec le nom 'customerService'. Mais si vous utilisez l'annotation @Service pour la classe de bean, vous pouvez fournir un nom de bean spécifique en

@Service("AAA")
public class CustomerService{

et vous pouvez obtenir l'objet de haricot par

CustomerService cust = (CustomerService)context.getBean("AAA");
9
Arun Raaj

Repository et Service sont les enfants de Component annotation. Donc, tous sont composant. Repository et Service développez-le simplement. De quelle façon précisément? Service n'a qu'une différence idéologique: nous l'utilisons pour des services. Repository a un gestionnaire d'exception particulier.

9
Maria Karpikova

Explication des stéréotypes:

  • @Service - Annotez toutes vos classes de service avec @Service. Cette couche connaît l'unité de travail. Toute votre logique métier sera dans les classes de service. Généralement, les méthodes de couche de service sont couvertes par une transaction. Vous pouvez effectuer plusieurs appels DAO à partir d'une méthode de service. Si une transaction échoue, toutes les transactions doivent être restaurées.
  • @Repository - Annotez toutes vos classes DAO avec @Repository. Toute votre logique d'accès à la base de données doit être dans les classes DAO.
  • @Component - Annotez vos autres composants (par exemple REST classes de ressources) avec un stéréotype de composant.
  • @Autowired - Laissez Spring connecter automatiquement d'autres haricots à vos classes à l'aide de l'annotation @Autowired.

@Component est un stéréotype générique pour tout composant géré par Spring. @Repository, @Service et @Controller sont des spécialisations de @Component pour des cas d'utilisation plus spécifiques, par exemple, dans les couches de persistance, de service et de présentation, respectivement.

A l'origine répondu ici .

5
Jeevan Patil

Au printemps, framework fournit un type spécial d’annotations, appelées annotations stéréotypées. Ce sont les suivants: -

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

les annotations déclarées ci-dessus sont spéciales car, lorsque nous ajoutons <context:component-scan> au fichier xxx-servlet.xml, spring crée automatiquement l'objet de ces classes annotées avec l'annotation ci-dessus pendant la phase de création/chargement du contexte.

3
Brajesh

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

@Component est un stéréotype générique pour les composants gérés par Spring @Repository, @Service et @Controller sont des spécialisations @Component pour des utilisations plus spécifiques:

  • @Repository pour la persistance
  • @Service pour services et transactions
  • @Controller pour les contrôleurs MVC

Pourquoi utiliser @Repository, @Service, @Controller sur @Component? Nous pouvons marquer nos classes de composants avec @Component, mais si nous utilisons plutôt l'alternative qui s'adapte à la fonctionnalité attendue. Nos classes sont mieux adaptées à la fonctionnalité attendue dans chaque cas particulier.

Une classe annotée avec "@Repository" a une meilleure traduction et une gestion des erreurs lisible avec org.springframework.dao.DataAccessException. Idéal pour l'implémentation de composants qui accèdent aux données (DataAccessObject ou DAO).

Une classe annotée avec "@Controller" joue un rôle de contrôleur dans une application Spring Web MVC

Une classe annotée avec "@Service" joue un rôle dans les services de logique applicative, exemple de modèle de façade pour DAO Manager (Facade) et le traitement des transactions.

2
UHDante

Les bonnes réponses sont ici pour expliquer les annotations de service de référentiel de composant. J'aimerais partager la différence entre _@Controller & @RestController_

@Controller vs RestController

@RestController:

enter image description here

  • Cette annotation est une version spécialisée de _@Controller_ qui ajoute automatiquement les annotations _@Controller_ et _@ResponseBody_. nous n’avons donc pas besoin d’ajouter _@ResponseBody_ à nos méthodes de mappage. Cela signifie que _@ResponseBody_ est actif par défaut.
  • Si vous utilisez _@RestController_, vous ne pouvez pas retourner de vue (en utilisant Viewresolver dans Spring/Spring-Boot)
  • _@RestController_ convertit également la réponse en _JSON/XML automatically_ en tant que _@ResponseBody_ transforme les objets retournés en quelque chose qui pourrait être dans le corps, _e.g. JSON or XML_

@Controller

enter image description here

  • _@Controller_ est utilisé pour marquer les classes en tant que contrôleur Spring MVC. Cette annotation est simplement une version spécialisée de _@Component_ et elle permet la détection automatique des classes de contrôleur en fonction de l'analyse du chemin d'accès aux classes.
  • _@Controller_ vous pouvez retourner une vue dans Spring Web MVC.

Vue plus détaillée

2
Patel Romil

Pour simplifier cette illustration, considérons la technicité par cas d’utilisation. Ces annotations sont utilisées pour être injectées et comme je l’ai dit littéralement " était utilisé pour être injecté ", cela signifie, si vous savez comment utiliser Dependency Injection "DI" et vous devriez le faire, alors vous chercherez toujours ces annotations, et en annotant les classes avec celles-ci Types stéréo , vous indiquez au conteneur DI de les analyser pour pouvoir les injecter à d'autres emplacements , c’est la cible pratique.

Passons maintenant à chacun; first @ Service , si vous construisez une logique pour une analyse de rentabilisation spécifique, vous devez la séparer dans un emplacement qui contiendra votre logique métier, ce service est: Classe normale ou vous pouvez l'utiliser comme interface si vous voulez, et il est écrit comme ceci

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

Tous sont identiques quand vous les injectez, @ Repository c'est une interface qui applique l'implémentation pour le modèle de référentiel modèle de conception de référentiel =, généralement, il est utilisé lorsque vous traitez avec un magasin de données ou une base de données, et vous verrez qu’il contient plusieurs implémentations prêtes pour que vous puissiez gérer les opérations de base de données; cela peut être CrudRepository , JpaRepository etc.

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

Enfin le @ @ Component , il s’agit du formulaire générique pour les haricots enregistrés au printemps, ce printemps est toujours à la recherche d’un haricot marqué avec @Component à enregistrer, @Service et @Repository sont des cas particuliers de @Component. Cependant, le cas d'utilisation courant d'un composant est lorsque vous créez quelque chose de purement technique et non pour couvrir une analyse de rentabilisation directe! comme le formatage des dates ou la manipulation du mécanisme de sérialisation des demandes spéciales, etc.

1
Mohamed Sweelam

Différence entre les annotations @Component, @Repository, @Controller & @Service

@Component - générique et peut être utilisé dans toutes les applications.
@ Service - annote les classes au niveau de la couche de service.
@ Controller - annotez les classes au niveau des couches de présentation, principalement utilisées dans Spring MVC.
@ Repository - annotez les classes sur la couche de persistance, qui agira en tant que référentiel de base de données.

@Controller = @Component (Annotation interne) + Caractéristiques de la couche de présentation
@ Service = @Component (annotation interne) + Caractéristiques de la couche de service
@ Composant = Composants réels (Beans)
@ Repository = @Component (annotation interne) + fonctionnalités de la couche de données (à utiliser pour la gestion des beans de domaine)

0
Lova Chittumuri