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

À Partir De Printemps De La Documentation :

au printemps 2.0 et plus tard, l'annotation @Repository est un marqueur pour toute classe qui remplit le rôle ou le stéréotype (également connu sous le nom de Objet d'accès ou DAO) d'un dépôt. Parmi les utilisations de ce marqueur est la traduction automatique d'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 Printemps-composant managé. @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 au lieu de cela, vos classes sont plus adapté au traitement par des outils ou s'associer avec des aspects. Par exemple, ces annotations stéréotypées faites des cibles idéales pour pointcuts.

ainsi, si vous choisissez entre @Component ou @Service pour votre couche de service, @Service est clairement le meilleur choix. Pareillement, comme indiqué ci-dessus, @Repository est déjà pris en charge comme marqueur pour traduction automatique d'exception 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)      │
└────────────┴─────────────────────────────────────────────────────┘

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

D'abord la similitude

le premier point à souligner encore une fois est que en ce qui concerne le balayage-auto-détection et l'injection de dépendance pour la définition de Beand toutes ces annotations (à savoir:, @Composant, @Service, @Référentiel, @Controller) sont les mêmes. nous pouvons utiliser un en place à l'autre et peut toujours obtenir notre chemin autour.

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

@Composante

il s'agit d'une annotation stéréotypée générale indiquant que la classe est une composante de ressort.

Qu'est-ce qui est spécial à propos de @Component

<context:component-scan> seulement scanne @Component et ne cherche pas @Controller , @Service et @Repository en général. Ils sont scannés parce qu'ils sont eux-mêmes annotés avec @Component .

il suffit de jeter un oeil à @Controller , @Service et @Repository annotation définitions:

@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 récupère et enregistre les classes suivantes comme des haricots, comme si elles étaient annotées avec @Component .

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

@Référentiel

indique que la classe définit un dépôt de données.

qu'est-ce que le dépôt@?

en plus de pointer out qu'il s'agit d'une Annotation basée Configuration , @Repository ’s tâche est d'attraper les exceptions spécifiques de plate-forme et de les jeter à nouveau comme l'un des Spring unified unchecked exception. Et pour cela, nous sommes fournis avec PersistenceExceptionTranslationPostProcessor , que nous sommes tenus d'ajouter dans le contexte d'application de notre printemps comme ceci:

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

ce bean post processor ajoute un conseiller à n'importe quel bean qui est annoté avec @Repository de sorte que toute plate-forme spécifique les exceptions sont capturées puis réimprimées comme l'une des exceptions non vérifiées du printemps pour l'accès aux données.

@Controller

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

qu'y a-t-il de spécial chez @Controller?

nous ne pouvons pas échanger cette annotation avec une autre comme @Service ou @Repository , même si elles semblent identiques. Le répartiteur scanne les classes annotées @Controller et détecte les annotations @RequestMapping à l'intérieur de celles-ci. Nous ne pouvons utiliser @RequestMapping sur @Controller classes annotées.

@Service

@Services tenir la logique métier et l'appel de la méthode dans le dépôt de la couche.

qu'y a-t-il de spécial à propos de @Service?

mis à part le fait qu'il est utilisé pour indiquer qu'il détient la logique d'affaires, il n'y a pas de spécialité notable que cette annotation fournit, mais qui sait, le printemps peut ajouter un peu plus exceptionnelle à l'avenir.

quoi d'autre?

similaire à ci-dessus, à L'avenir le printemps peut choisir d'ajouter des fonctionnalités spéciales pour @Service , @Controller et @Repository basé sur leurs conventions de superposition. C'est pourquoi il est toujours bon de respecter la convention et de l'utiliser en ligne avec les couches.

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

• @Controller les haricots sont utilisés par Printemps-mvc
• @Repository les haricots sont admissibles à la traduction de l'exception relative à la persistance

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

Une chose @Component offres est que vous pouvez annoter d'autres annotations, et ensuite 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 le code qui gère le spécifique annotation.

@Composant est équivalent à

<bean>

@Service, @Contrôleur, @Repository = {@Component + certains plus des fonctionnalités spéciales}

signifie Service, le contrôleur et le dépôt sont fonctionnellement identiques.

les trois annotations sont utilisées pour séparer "couches dans votre demande,

• les contrôleurs font des choses comme méthodes d'expédition, de transit, de service téléphonique, etc.
• Service Maintenez la Logique d'entreprise, Calculs etc.
• dépôt sont les DAOs (Data Access Objects), ils accèdent à la base de données directement.

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é de la couche DAO seulement. Vous écrirez un Aspect (une classe) classe qui fait une journalisation avant et après chaque méthode de votre DAO est invoquée, vous êtes en mesure de le faire en utilisant AOP car vous avez trois couches distinctes et ne sont pas mélangées.

pour que vous puissiez faire la journalisation de DAO" autour"," avant "ou" après " les méthodes DAO. Tu pouvais faire ça parce que tu avais 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 annotation @Controller, alors ce component aura dispatching, business logic et l'accès à la base de données tout mélangé, donc du code sale!

ci-dessus mentionné est un scénario très commun, Il ya beaucoup plus de cas d'utilisation de pourquoi utiliser trois annotations.

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

@Controller: où votre demande cartographie à partir de la page de présentation fait c.-à-d. la couche de présentation ne va pas à tout autre fichier, il va directement à @Controller classe et vérifie le chemin demandé dans @RequestMapping annotation qui écrit avant les appels de méthode si nécessaire.

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

@Repository : couche de persistance(couche D'accès aux données) de l'application qui a utilisé pour obtenir des données à partir de la base de données. i.e. toute la base de données les opérations connexes sont effectuées par le dépôt.

@Component - annotez vos autres composants (par exemple les classes REST resource) avec un stéréotype de Composant.

indique qu'une classe annotée est un " composant ". Ces classes sont considéré comme candidat à l'auto-détection lors de l'utilisation configuration basée sur l'annotation et numérisation classpath.

autres les annotations au niveau de la classe peuvent être considérées comme composant aussi, généralement un type spécial de Composant: par exemple, le L'annotation @Depository ou l'annotation @Aspect d'AspectJ.

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 toute composante gérée par ressort, alors que @Repository, @Service et @Controller servent de spécialisations de la composante pour des cas d'utilisation plus spécifiques (p. ex., dans les couches persistence, service et 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 de stéréotype font des cibles idéales pour les pointcuts. Bien sûr, il est également possible que @Repository, @Service et @Controller puissent apporter des éléments sémantiques supplémentaires dans les futures versions du cadre de printemps. 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 comme marqueur pour la traduction automatique d'exception dans votre couche persistence.

@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 de ressort-numérisation Classpath, composants gérés et configurations d'écriture utilisant Java

utilisation de @Service et @Repository les annotations sont importantes du point de vue de la connexion aux bases de données.

1. Utiliser @Service pour l'ensemble de votre service web de type de DB connections
2. utiliser @Repository pour toutes vos connexions proc DB stockées

si vous n'utilisez pas les annotations appropriées, vous pouvez vous attendre à ce que les exceptions de commit soient annulées par des opérations de roll-back. Vous verrez des exceptions pendant le stress test de charge lié aux transactions JDBC.

@Référentiel @Service et @Controller sont sert de spécialisation de @Composant pour utilisation plus spécifique sur cette base, vous pouvez remplacer @Service à @Composant, 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.

toutes ces annotations sont de type stéréo type type d'annotation,la différence entre ces trois annotations sont

• si nous ajoutons le "Component" alors il dit que le rôle de la classe est une classe de composants, cela signifie qu'il s'agit d'une classe constituée d'une certaine logique, mais elle ne dit pas si une classe contenant une entreprise spécifique ou la persistance ou la logique du contrôleur donc nous n'utilisons pas directement ceci @Annotation du composant
• si nous ajoutons @ service annotation alors il indique qu'un rôle de classe consistant logique d'affaires
• si nous ajoutons @Repository en haut de la classe alors il indique qu'une classe consistant en une logique de persistance
• Ici @est un Composant de base de l'annotation @Service,@Référentiel et @Contrôleur annotations

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 @Service ou @Repositroy ou @Controller annotation par défaut @Component annotation est d'aller à l'existence le premier de la classe

ressort fournit quatre types différents d'annotations de balayage de Composant auto, ils sont @Component , @Service , @Repository et @Controller . Techniquement, il n'y a pas de différence entre eux, mais chaque annotation de scan de Composant automatique doit être utilisée pour un usage spécial et dans la couche définie.

@Component : il s'agit d'une annotation de numérisation automatique de base, elle indique que la classe annotée est un composant de numérisation automatique.

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

@Service : indique que la classe annotée est une composante de Service dans la couche affaires.

@Repository : vous devez utiliser cette annotation dans la couche de persistance, cela agit comme un dépôt de base de données.

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

techniquement @Controller, @Service, @Repository sont tous les mêmes. Tous d'eux s'étend @Composants.

du code source du ressort:

Indique qu'une classe annotée est un "composant". Ces classes sont considérées comme des candidats à la détection automatique lorsqu'on utilise la configuration basée sur l'annotation et la numérisation classpath.

nous pouvons utiliser directement @Component pour chaque haricot, mais pour une meilleure compréhension et maintenabilité d'une grande application, nous utilisons @Contrôleur, @Service, @Référentiel.

but de chaque annotation:

1) @Controller -> Les Classes annotées avec ceci, sont destinées à recevoir une requête du côté client. La première requête vient du servlet du répartiteur, d'où elle passe la requête au contrôleur particulier en utilisant la valeur de @RequestMapping annotation.

2) @Service - > Les Classes annotées de la présente, sont destinées à: manipulez les données, que nous recevons du client ou récupérons de la base de données. Toutes les manipulations avec des données doivent être faites dans cette couche.

3) @Repository -> les Classes annotées avec ceci, sont destinées à se connecter avec la base de données. Il peut également être considéré comme couche DAO(Data Access Object). Cette couche devrait être limitée aux opérations CRUD (create, retrieve, update, delete) seulement. Si des manipulations sont nécessaires, les données doivent être envoyées à la couche @Service.

si nous échangeons leur place(utiliser @Repository à la place de @Controller), notre application fonctionnera très bien.

le but principal de l'utilisation de trois @annotations différentes est de fournir une meilleure modularité à l'application D'entreprise.

annoter les autres composants avec @Component, par exemple les classes REST Resource.

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

@est un stéréotype générique pour toute composante gérée par ressort.

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

@composant au printemps

nous pouvons répondre à cela selon la norme java

se référant à JSR-330 , qui est maintenant supporté par le ressort, vous ne pouvez utiliser @Named pour définir un haricot (en quelque sorte @Named=@Component ). Ainsi, selon cette norme, il semble qu'il ne soit pas utile de définir les stéréotypes (comme @Repository , @Service , @Controller ) aux catégories haricots.

mais l'utilisateur de ressort ces différentes annotations dans différent pour l'utilisation spécifique, pour exemple:

1. aider les développeurs à définir une meilleure catégorie pour les personnes compétentes. Cette catégorisation peut devenir utile dans certains cas. (Par exemple, lorsque vous utilisez aspect-oriented , ceux-ci peuvent être un bon candidat pour pointcuts )
2. @Repository l'annotation ajoutera certaines fonctionnalités à votre haricot (une traduction automatique d'exception à votre couche de persistance de haricot).
3. si vous utilisez le ressort MVC, le @RequestMapping ne peut être ajouté qu'aux classes annotées par @Controller .

au printemps 4, dernière version:

l'annotation @Repository est un marqueur pour toute classe qui remplit les rôle ou stéréotype d'un dépôt (aussi connu sous le nom D'objet D'accès aux données) ou DAO). Parmi les utilisations de ce marqueur est la traduction automatique de exceptions décrites à la Section 20.2.2, "traduction de L'Exception".

Spring fournit d'autres annotations stéréotypées: @Component, @Service, et @Contrôleur. @Composant est un générique de stéréotype pour tout Printemps-composant managé. @Repository, @Service, et @Controller sont spécialisation de la composante @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 mieux adaptées pour traitement par outils ou association avec aspect. Par exemple, ces stéréotype annotations des cibles idéales pour les pointcuts. Il est également il est possible que @Repository, @Service et @Controller puissent transporter sémantique supplémentaire dans les futures versions du cadre de printemps. Ainsi, si vous choisissez entre @Component ou @Service pour votre la couche de service @Service est clairement le meilleur choix. De même, comme indiqué ci-dessus, @Référentiel est déjà pris en charge comme un marqueur de traduction automatique d'exception dans votre persistance couche.

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

il se comportera de la même manière, mais un aspect est qu'ils ne seront pas en mesure de saisir une exception spécifique liée à DAO au lieu de dépôt si nous utilisons component ou @ service

Il n'y a pas de différence entre @Composant,@Service,@Contrôleur,@Référentiel. @Component est l'annotation générique pour représenter le composant de notre MVC. Mais il y aura plusieurs composants faisant partie de notre application MVC comme les composants de la couche de service, les composants de la couche de persistance et les composants de la couche de présentation. Ainsi pour les différencier les gens de printemps ont donné les trois autres annotations aussi.

pour représenter les composantes de la couche de persistance: @dépôt final

pour représenter les composantes 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 chacun d'eux.

Un @Service , pour citer le printemps de la documentation,

Indique qu'une classe annotée est un "Service", défini à l'origine par Domaine-Driven Design (Evans, 2003) comme "une opération interface qui se tient seul dans le modèle, sans état encapsulé." Peut également indiquer qu'une classe est une "façade de service D'affaires" (dans Core J2EE patterns sense), ou quelque chose de similaire. Cette annotation est une les stéréotypes généralistes et les équipes individuelles peuvent sémantique et utilisation appropriée.

Si vous regardez le domain driven design par eric evans,

un SERVICE est une opération offerte en tant qu'interface le modèle, sans état d'encapsulation, en tant qu'entités et objets de valeur faire. Les SERVICES sont un modèle courant dans les cadres techniques, mais ils peut également s'appliquer dans la couche domaine. Nom le service met l'accent sur l' relation avec d'autres objets. Contrairement aux entités et aux objets de valeur, est défini uniquement en fonction de ce qu'il peut faire pour un client. SERVICE tend à être nommé pour une activité, plutôt qu'une entité-un verbe plutôt qu'à un nom. Un SERVICE peut encore avoir un Abstrait, intentionnel définition; il a juste une saveur différente que la définition d'un objet. Un SERVICE devrait toujours avoir une responsabilité définie, et que la responsabilité et l'interface devrait être défini comme la partie du modèle de domaine. Les noms d'opération doivent provenir du La langue est omniprésente ou y est introduite. Paramètres et résultats devrait être des objets du domaine. Les SERVICES devraient être utilisés de façon judicieuse et non autorisé à dépouiller les entités et les objets de valeur de tout leur comportement. Mais lorsqu'une opération est en fait un concept de domaine important, Le SERVICE fait naturellement partie d'une conception basée sur le modèle. Déclaré dans le modèle comme un SERVICE, plutôt que comme un objet bidon qui ne pas en fait représentent quelque chose, l'opération autonome ne sera pas induire en erreur quiconque.

et un Repository selon Eric Evans,

un dépôt représente tous les objets d'un certain type comme un concept groupe (généralement émulé). Il agit comme une collection, sauf avec plus capacité d'interrogation élaborée. Les objets du type approprié sont ajouté et retiré, et la machinerie derrière le dépôt insère ou les supprime de la base de données. Cette définition regroupe un ensemble cohérent de responsabilités pour assurer l'accès aux Agrégats à partir du début du cycle de vie jusqu'à la fin.

@Component est le premier niveau générique annotation qui rend le annoté de la fève à être numérisés et disponibles dans le conteneur d'injection de dépendances

@Repository est annotation spécialisée et il apporte la caractéristique de convertir toutes les exceptions non vérifiées des classes DAO

@Service est annotation spécialisée. il n'apporter aucune nouvelle fonctionnalité de maintenant, mais il précise l'objet de la fève

@Contrôleur est annotation spécialisée qui rend le bean MVC conscient et permet l'utilisation d'autres annotations comme @RequestMapping et tous ces

en savoir plus détails

@Component : vous annotez une classe @Component, il dit hibernate qu'il s'agit d'un haricot.

@Repository : vous annotez une classe @Repository, elle indique qu'elle est une classe DAO et la traite comme classe DAO. Cela signifie qu'il rend les exceptions non vérifiées (jetées à partir des méthodes DAO) éligibles pour la traduction dans L'exception de L'accès aux données du printemps.

@Service : cela dit hibernation il est une classe de Service où vous aurez des annotations de la couche de Service @Transactional etc donc hibernate le traite comme un composant de Service.

Plus @Service est en avance de @Composant. Supposons que le nom de la classe de haricot est CustomerService, puisque vous n'avez pas choisi la configuration XML du haricot, vous avez donc annoté le haricot avec @Component pour l'indiquer comme un haricot. Ainsi, tout en obtenant l'objet bean CustomerService cust = (CustomerService)context.getBean("customerService"); par défaut, le ressort va cas le premier caractère du composant-de ‘La clientele’ à ‘support’. Et vous pouvez récupérer ce composant avec le nom "customerService". Mais si vous utilisez @service annotation pour la classe de haricot vous pouvez fournir un nom de haricot spécifique par

@Service("AAA")
public class CustomerService{

et vous pouvez obtenir l'objet d'haricot par

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

@Component cette annotation est utilisée sur les classes pour indiquer un composant de ressort.Il marque la classe Java comme un haricot ou un composant de sorte que le mécanisme de balayage de composant de Spring peut l'ajouter dans le contexte de l'application.

@Repository cette annotation est utilisée sur les classes Java qui accèdent directement à la base de données.Il fonctionne comme marqueur pour toute classe qui remplit le rôle de dépôt ou D'objet D'accès aux données.Cette annotation comporte une fonction de traduction automatique. Par exemple, lorsqu'une exception se produit dans le @Référentiel, il y a un gestionnaire pour que l'exception, et il n'est pas nécessaire d'ajouter un bloc try-catch.

@Service il s'agit d'une classe Java qui fournit certains services, tels que l'exécution de la logique commerciale, l'exécution de calculs et l'appel D'API externes. Cette annotation est une forme spécialisée de l'annotation @Component destinée à être utilisée dans la couche service.

@Controller cette annotation est utilisée pour indiquer la classe est un contrôleur à ressort.

explication des stéréotypes:

• @Service - Annotez toutes vos classes de service avec @Service. Cette couche sait que l'unité de travail. Toute la logique de votre entreprise sera dans les classes de Service. En général, les méthodes de la couche service sont couvertes par la transaction. Vous pouvez faire plusieurs appels D'OFA depuis la méthode de service, si une transaction échoue, toutes les transactions devraient être annulées.
• @Repository - annoté toutes vos classes DAO avec @Repository. Toute la logique d'accès à votre base de données doit être dans les classes DAO.
• @Component - annotez vos autres composants (par exemple les classes REST resource) avec le stéréotype du composant.
• @Autowired - Laissez-le Printemps de l'auto-fil autres haricots dans vos classes à l'aide de @Autocâblés annotation.

@Component est un stéréotype générique pour tout composant à ressort. @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.

à l'Origine répondu ici .

@Composant, @ Référentiel, @ Service, @Contrôleur:

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

• @dépôt pour la persistance
• @de Service pour les services et les transactions
• @Contrôleur des contrôleurs MVC

Pourquoi utiliser @Référentiel, @Service, @Contrôleur @Composant? Nous pouvons marquer nos classes de composants avec @Component, mais si à la place nous utilisons l'alternative qui s'adapte à la fonctionnalité attendue. Nos cours sont mieux adaptés aux fonctionnalités attendues dans chaque cas particulier.

d'Une classe annotée avec "@Référentiel" a une meilleure traduction et lisible de la gestion d'erreur avec org.springframework.dao.DataAccessException. Idéal pour la mise en œuvre de composants qui accèdent aux données (DataAccessObject ou DAO).

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

Une classe annotée avec "@" Service joue un rôle dans une logique d'entreprise de services, exemple de la Façade modèle de DAO Manager (Façade) et la gestion des transactions

dans spring framework fournit un type particulier 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 ci-dessus sont spéciales parce que lorsque nous ajoutons <context:component-scan> dans xxx-servlet.xml file, spring créera automatiquement l'objet des classes annotées avec l'annotation ci-dessus pendant la phase de création/chargement du contexte.

Référentiel et Service sont les enfants de Composant annotation. Donc, Tous sont composant . Référentiel et Service juste à le développer. Comment exactement? Service n'a qu'une différence idéologique: nous l'utilisons pour des services. Référentiel a particulier gestionnaire d'exception.

avant d'apprendre la différence entre @Component, @Service, @Controller, and @Repository annotations dans le cadre de printemps, il est important de comprendre le rôle de @Component annotation au printemps. Lors de la sortie initiale de Spring, tous les grains sont utilisés pour être déclarés dans un fichier XML. Pour un grand projet, cela devient rapidement une tâche énorme et les gars de Spring reconnaissent le problème assez rapidement. Dans les versions ultérieures, ils fournissent l'injection de dépendances basée sur l'annotation et la configuration basée sur Java. À Partir Du Printemps 2.5 l'injection de dépendance basée sur l'annotation a été introduite, qui scanne et enregistre automatiquement les classes comme étant Spring bean, ce qui est annoté en utilisant l'annotation @Component . Cela signifie que vous ne devez pas déclarer que bean en utilisant la balise et injecter la dépendance, cela sera fait automatiquement au printemps. Cette fonctionnalité a été activée et désactivée en utilisant la balise <context:component-scan> .

maintenant que vous savez ce que fait @Component l'annotation fait voyons ce que fait @Service, @Controller, and @Repository l'annotation fait. Ils ne sont rien d'autre que la forme spécialisée de @Component annotation pour certaines situations. Au lieu d'utiliser @Component sur une classe de contrôleur au printemps MVC, nous utilisons @Controller , qui est plus lisible et plus approprié.

en utilisant cette annotation, nous faisons deux choses, d'abord, nous déclarons que cette classe est un grain de printemps et devrait être créé et maintenu par Spring ApplicationContext, mais aussi nous indiquons que son contrôleur dans la configuration MVC. Cette dernière propriété est utilisé par des outils et des fonctionnalités spécifiques au web.

par exemple, DispatcherServlet cherchera @RequestMapping sur les classes qui sont annotées en utilisant @Controller mais pas avec @Component .

cela signifie @Component et @Controller sont les mêmes en ce qui concerne la création de haricots et l'injection de dépendance, mais plus tard est une forme spécialisée de la première. Même si vous remplacez @Controller annotation par @Compoenent , le ressort peut automatiquement détecter et enregistrez la classe controller, mais elle peut ne pas fonctionner comme vous l'attendez en ce qui concerne le mappage des requêtes.

idem pour @Service et @Repository annotation, il s'agit d'une spécialisation de @Component dans la couche de service et de persistance. Un haricot de printemps dans la couche de service devrait être annoté en utilisant @Service au lieu de @Component et un haricot de printemps dans la couche de persistance devrait être annoté avec @Repository .

En utilisant une annotation spécialisée, nous frappons deux oiseaux d'une pierre. Premièrement, ils sont traités comme des haricots de printemps et deuxièmement, vous pouvez mettre un comportement spécial requis par cette couche.

par exemple, @Repository's n'aide pas seulement dans la configuration basée sur les annotations, mais aussi attrape des exceptions spécifiques à la plate-forme et les renvoie comme l'une des exceptions unifiées non vérifiées du printemps.

bien que pour cela vous devez également déclarer org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor comme haricot de printemps dans votre contexte de l'application.

ce bean post processeur ajoute un conseiller à n'importe quel bean qui est annoté avec @Repository de sorte que n'importe quelles exceptions spécifiques à la plate-forme sont attrapées et puis réarrangées comme l'une des exceptions D'accès de données non vérifiées du printemps.

j'espère qu'après avoir lu ceci vous aurez une compréhension claire concernant @Component, @Service, @Controller, and @Repository .

merci de donner votre temps et de lire mon billet.

@component
@controller
@Repository
@service
@RestController

ce sont tous des annotations stéréotypées. Si nous avons placé @controller au sommet de la classe. Il ne deviendra pas une classe de controller basée sur les différents calques(composants) que nous pouvons annoter avec ces annotations mais le compilateur ne fera rien à ce sujet juste pour la compréhension du développeur but nous pouvons choisir basé sur les composants que nous devons écrire des annotations