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


Pouvez @Component, @Repository et @Service Les annotations peuvent-elles être utilisées de manière interchangeable au printemps ou fournissent-elles des fonctionnalités particulières en plus d'agir comme un système de notation?

En d'autres termes, si j'ai une classe Service et que je change l'annotation de @Service à @Component, va-t-il encore se comporter de la même manière?

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


1515
2017-07-26 09:10


origine


Réponses:


De Documentation printanière:

Au printemps 2.0 et plus tard, le @Repository l'annotation est un marqueur pour   toute classe qui remplit le rôle ou le stéréotype (également connu sous le nom   Access Object ou DAO) d'un référentiel. Parmi les utilisations de ce marqueur   est la traduction automatique des exceptions.

Spring 2.5 introduit d'autres annotations stéréotypées: @Component,    @Service, et @Controller. @Component est un stéréotype générique pour tout   Composant géré par un ressort. @Repository, @Service, et @Controller sont   spécialisations de @Component pour des cas d'utilisation plus spécifiques, pour   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   à la place, vos classes sont plus adaptées au traitement par outils   ou en associant avec des aspects. Par exemple, ces annotations stéréotypées   faire des cibles idéales pour les points de coupure.

Ainsi, si vous choisissez entre l'utilisation @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   traduction d'exception automatique 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)      │
└────────────┴─────────────────────────────────────────────────────┘

1110
2017-08-01 10:20



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

Premièrement la Similarité 

Le premier point qui mérite d'être souligné est que en ce qui concerne la détection automatique et l'injection de dépendances pour BeanDefinition toutes ces annotations (à savoir, @Component, @Service,   @Repository, @Controller) sont les mêmes. Nous pouvons en utiliser un en place   d'un autre et peut toujours se déplacer.


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

@Composant

Ceci est une annotation de stéréotype à usage général indiquant que la classe est un composant de ressort.

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

Jetez un oeil à @Controller, @Service et @Repository définitions d'annotation:

@Component
public @interface Service {
    ….
}

@Component
public @interface Repository {
    ….
}

@Component
public @interface Controller {
    …
}

Ainsi, il n'est pas faux de dire que @Controller, @Service et @Repository sont des types spéciaux de @Component annotation. <context:component-scan> les ramasse et enregistre leurs classes suivantes comme des haricots, comme s'ils étaient annotés avec @Component.

Ils sont scannés car ils sont eux-mêmes annotés @Component annotation. Si nous définissons notre propre annotation personnalisée et l'annotons avec @Component, alors il sera également scanné avec <context:component-scan>


@Dépôt

C'est pour indiquer que la classe définit un référentiel de données.

Quelle est la particularité de @Repository? 

En plus de souligner que c'est un Configuration basée sur l'annotation, @RepositoryLe travail consiste à attraper les exceptions spécifiques à la plate-forme et à les relancer comme l'une des exceptions non vérifiées unifiées de Spring. Et pour cela, nous sommes fournis avec PersistenceExceptionTranslationPostProcessor, que nous sommes tenus d'ajouter dans notre contexte d'application de printemps 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 réinspectées comme l'une des exceptions d'accès aux données non contrôlées de Spring.


@Manette

le @Controller L'annotation indique qu'une classe particulière joue le rôle d'un contrôleur. le @Controller l'annotation agit comme un 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 d'autres comme @Service ou @Repository, même si elles ont l'air identiques. Le répartiteur analyse les classes annotées avec @Controller et détecte @RequestMapping annotations en leur sein. Nous ne pouvons utiliser @RequestMapping sur @Controller classes annotées.


@Un service

@Services Conserver la logique métier et la méthode d'appel dans la couche du référentiel.

Quelle est la particularité de @Service? 

Mis à part le fait qu'il est utilisé pour indiquer qu'il contient la logique métier, il n'y a pas de spécialité notable que cette annotation fournit, mais qui sait, le printemps pourrait ajouter quelque chose d'exceptionnel à l'avenir.


Quoi d'autre?

Similaire à ce qui précède, à l'avenir, le printemps peut choisir d'ajouter des fonctionnalités spéciales pour @Service, @Controller et @Repository en fonction de leurs conventions de superposition. C'est donc toujours une bonne idée de respecter la convention et de l'utiliser en ligne avec les calques.


423
2017-07-24 06:43



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

  • @Controller les haricots sont utilisés par spring-mvc
  • @Repository les haricots sont éligibles pour la traduction d'exception de persistance

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

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

Par exemple récemment j'ai fait:

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

Donc, toutes les classes annotées avec @ScheduledJob sont des haricots de printemps et en plus de cela sont enregistrés comme emplois de quartz. Vous avez juste à fournir du code qui gère l'annotation spécifique.


388
2017-07-26 09:16



@Component est équivalent à

<bean>

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

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

Les trois annotations sont utilisées pour séparer "Couches" dans votre application,

  • Les contrôleurs effectuent des tâches telles que la répartition, le transfert, l'appel de méthodes de service, etc.
  • Logique métier, calculs, etc.
  • Repository sont les DAO (Data Access Objects), ils accèdent directement à la base de données.

Maintenant, vous pouvez vous demander pourquoi les séparer: (Je suppose que vous connaissez AOP-Aspect Oriented Programming)

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

Donc, vous pouvez faire la journalisation de DAO "autour", "avant" ou "après" les méthodes DAO. Vous pourriez le faire parce que vous avez eu un DAO en premier lieu. Ce que vous venez d'accomplir est Séparation des préoccupations ou des tâches.

Imaginez s'il n'y avait qu'une seule annotation @Controller, alors ce composant aura la répartition, la logique métier et l'accès à la base de données tous mélangés, code tellement sale!

Ci-dessus mentionné est un scénario très commun, il y a beaucoup plus de cas d'utilisation de pourquoi utiliser trois annotations.


332
2018-05-23 05:15



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

@Controller: où votre demande  mappage depuis la page de présentation fait, c'est-à-dire que la couche de présentation ne va pas à un autre fichier, il va directement à @Controller classe et vérifie le chemin demandé dans @RequestMapping annotation qui a été écrite avant les appels de méthode si nécessaire.

@Service: Toute la logique métier est ici, c'est-à-dire les calculs liés aux données et tous.Cette annotation de couche métier dans laquelle notre utilisateur n'appelle pas directement la méthode de persistance, il appellera cette méthode en utilisant cette annotation. Il demandera @Repository selon la demande de l'utilisateur

@Repository: Il s'agit de la couche de persistance (Data Access Layer) de l'application qui permet d'obtenir des 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 - Annoter vos autres composants (par exemple les classes de ressources REST) ​​avec un stéréotype de composant.

Indique qu'une classe annotée est un "composant"Ces classes sont   considérés comme candidats à l'auto-détection lors de l'utilisation   configuration basée sur des annotations et analyse de classpath.

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

enter image description here


188
2018-03-25 08:00



Spring 2.5 introduit d'autres annotations stéréotypées: @Component, @Service et @Controller. @Component sert de stéréotype générique pour tout composant géré par Spring; tandis 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 composants avec @Component, mais en les annotant avec @Repository, @Service ou @Controller à la place, vos classes sont plus adaptées au traitement par outils ou à l'association avec des aspects. Par exemple, ces annotations stéréotypées constituent des cibles idéales pour les coupes ponctuelles. Bien sûr, il est également possible que @Repository, @Service, et @Controller puissent transporter des sémantiques supplémentaires dans les futures versions de Spring Framework. Ainsi, si vous prenez une décision entre 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 :- Spring Documentation - Analyse de classpath, composants gérés et écriture de configurations à l'aide de Java  


59
2018-05-15 12:48



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

Vous remarquerez que tout @Repository,@Service ou @Controller sont annotés avec @Component. Alors, pouvons-nous utiliser juste @Component pour tous les composants pour la numérisation automatique? Oui, vous le pouvez, et Spring analysera automatiquement tous vos composants avec @Component annoté.

Cela fonctionne bien, mais pas une bonne pratique, pour la lisibilité, vous devriez toujours déclarer @Repository,@Service ou @Controller pour une couche spécifiée pour rendre votre code plus facile à lire.


51
2017-12-16 18:10



Utilisation de @Service et @Repository Les annotations sont importantes du point de vue de la connexion à la base de données.

  1. Utilisation @Service pour tout votre type de service Web de connexions DB
  2. Utilisation @Repository pour toutes vos connexions DB de processus stockées

Si vous n'utilisez pas les annotations appropriées, vous pouvez faire face à des exceptions de validation remplacées par des transactions de restauration. Vous verrez des exceptions au cours du test de charge de stress liées aux transactions JDBC de restauration.


40
2017-11-02 16:05