java - francais - spring @service




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

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.

reference: - Spring Documentation - Analyse de classpath, composants gérés et écriture de configurations en Java

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

En d'autres termes, si j'ai une classe Service et que je modifie l'annotation de @Service à @Component , est-ce qu'elle se comportera toujours de la même manière?

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


1. La différence majeure entre ces stéréotypes est qu'ils sont utilisés pour une classification différente.

2. Dans une application à plusieurs niveaux, nous aurons différentes couches comme la présentation, le service, l'entreprise, l'accès aux données, etc. Quand une classe doit être annotée pour la détection automatique par Spring, nous devrions utiliser le stéréotype respectif comme ci-dessous.

  • @Component - générique et peut être utilisé à travers l'application.
  • @Service - annote les classes au niveau de la couche de service.
  • @Controller - annote les classes au niveau des couches de présentation, principalement utilisées dans Spring MVC.
  • @Repository - annote des classes à la couche de persistance, qui agira comme référentiel de base de données. Si techniquement ils vont être identiques alors pourquoi avons-nous besoin de les utiliser au niveau des couches différentes. Pourquoi ne pas utiliser la même chose à tous les niveaux. Par exemple, si nous utilisons @Service dans toutes les couches, tous les beans seront instanciés et aucun problème. Il y a une différence mineure, par exemple considérons @Repository.

Le postprocesseur recherche automatiquement tous les traducteurs d'exception (implémentations de l'interface PersistenceExceptionTranslator) et conseille tous les beans marqués avec l'annotation @Repository afin que les traducteurs reconnus puissent intercepter et appliquer la traduction appropriée sur les exceptions levées.

  1. Similaire à ce qui précède, à l'avenir, Spring peut choisir d'ajouter de la valeur pour @Service , @Controller et @Repository fonction de leurs conventions de superposition. Pour cet avantage supplémentaire, il est préférable de respecter la convention et de l'utiliser en ligne avec les calques.
  2. Outre ce qui précède, en ce qui concerne la détection automatique , l'injection de dépendances pour BeanDefinition @Component , @Service , @Repository et @Controller sont identiques.
  3. Selon la documentation de Spring: L'annotation @Repository est un marqueur pour toute classe qui remplit le rôle ou le stéréotype d'un référentiel (également connu sous le nom d'objet d'accès aux données ou DAO ). Parmi les utilisations de ce marqueur, la traduction automatique des exceptions est décrite à la Section 20.2.2, «Traduction d'exception». Spring fournit 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 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 à la place, vos classes sont plus appropriées pour le 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. Il est également possible que @Repository, @Service et @Controller puissent comporter des sémantiques supplémentaires dans les futures 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.

Annoter d'autres composants avec @Component, par exemple des classes de ressources REST.

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

@Component au printemps


Au printemps 4, dernière version:

L'annotation @Repository est un marqueur pour toute classe qui remplit le rôle ou le stéréotype d'un référentiel (également appelé objet DAO). Parmi les utilisations de ce marqueur, la traduction automatique des exceptions est décrite à la Section 20.2.2, «Traduction d'exception».

Spring fournit 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 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 à la place, vos classes sont plus appropriées pour le 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. Il est également possible que @Repository, @Service et @Controller puissent comporter des sémantiques supplémentaires dans les futures 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.


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

@Controller: où votre requête mappage à partir de la page de présentation, c'est-à-dire la couche de présentation ne va pas à un autre fichier, elle va directement dans la classe @Controller et vérifie le chemin demandé dans l'annotation @RequestMapping écrite avant les appels de méthodes si nécessaire.

@Service : Toute la logique métier est ici ie 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. toutes les opérations liées à la base de données sont effectuées par le référentiel.

@Component - @Component 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 " component ". De telles classes sont considérées comme candidates à la détection automatique lors de l'utilisation de la configuration basée sur des annotations et de l'analyse de chemin de classe.

D'autres annotations au niveau de la classe peuvent être considérées comme identifiant un composant, typiquement un type particulier de composant: par exemple l'annotation @Repository ou l'annotation @Aspect d'AspectJ.

component


Dans une application à plusieurs niveaux, nous aurons différentes couches comme la présentation, le service, l'entreprise, l'accès aux données, etc. Lorsqu'une classe doit être annotée pour la détection automatique par Spring, nous devrions utiliser le stéréotype respectif comme ci-dessous.

  • @Component - générique et peut être utilisé à travers l'application.
  • @Service - annote les classes au niveau de la couche de service.
  • @Controller - annote les classes au niveau des couches de présentation, principalement utilisées dans Spring MVC.
  • @Repository - annote des classes à la couche de persistance, qui agira comme référentiel de base de données.

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. Mais il y aura plusieurs composants dans notre application MVC comme les composants de couche de service, les composants de couche de persistance et les 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 chacun d'entre eux.


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

  • @Controller haricots @Controller sont utilisés par spring-mvc
  • @Repository beans @Repository 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 que @Component propose est que vous pouvez annoter d'autres annotations avec lui, 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 travaux de quartz. Vous avez juste à fournir du code qui gère l'annotation spécifique.


Les @Component Spring @Component , @Service , @Repository et @Controller sont utilisées pour la détection automatique du bean à l'aide de l'analyse classpath dans Spring framework.

@Component est une annotation générique. Différence de @Service , @Repository , @Controller avec @Component est que ce sont des cas spéciaux de @Component et utilisés à des fins particulières. La différence n'est que la classification.

Pour toutes ces annotations (stéréotypes), techniquement, le but principal est le même. Spring analyse et identifie automatiquement toutes ces classes qui sont annotées avec " @Component , @Service , @Repository , @Controller " et enregistre la définition de bean avec ApplicationContext .


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 d'attraper une exception spécifique liée à DAO au lieu de référentiel si nous utilisons le composant ou @ service


Spring propose quatre types différents d'annotations d'analyse automatique des composants: @Component , @Service , @Repository et @Controller . Techniquement, il n'y a pas de différence entre eux, mais chaque annotation d'analyse de composant automatique doit être utilisée dans un but spécial et dans la couche définie.

@Component : il s'agit d'une annotation d'analyse de composant automatique de base, 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 de contrôleur, et principalement utilisé dans la couche de présentation.

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

@Repository : Vous devez utiliser cette annotation avec dans la couche de persistance, cela 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 allant de l'avant.


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

De source code source:

Indique qu'une classe annotée est un "composant". De telles classes sont considérées comme candidates à la détection automatique lors de l'utilisation de la configuration basée sur des annotations et de l'analyse de chemin de classe.

Nous pouvons directement utiliser @Component pour chaque beans, mais pour une meilleure compréhension et maintenabilité de grandes applications, nous utilisons @Controller, @Service, @Repository.

But de chaque annotation:

1) @Controller -> Les classes annotées avec ceci, sont destinées à recevoir une requête du côté client. First request comes to the Dispatcher Servlet, from where it passes the request to the particular controller using value of @RequestMapping annotation.

2) @Service -> Classes annotated with this, are intended to manipulate data, that we receive from client or fetch from database. All the manipulation with data should be done in this layer.

3) @Repository -> Classes annotated with this, are intended to connect with database. It can also be considered as DAO(Data access Object) layer. This layer should be restricted to CRUD (create,retrieve,update,delete) operations only. If any manipulation is required, data should be send be send back to @Service layer.

If we interchange their place(use @Repository in place of @Controller), our application will work fine.

The main purpose of using three different @annotations is to provide better Modularity to the Enterprise application.


@Component is the top level generic annotation which makes the annotated bean to be scanned and available in the DI container

@Repository is specialized annotation and it brings the feature of converting all the unchecked exceptions from the DAO classes

@Service is specialized annotation. it do not bring any new feature as of now but it clarifies the intent of the bean

@Controller is specialized annotation which makes the bean MVC aware and allows the use of further annotation like @RequestMapping and all such

Here are more details


@Component : you annotate a class @Component, it tells hibernate that it is a Bean.

@Repository : you annotate a class @Repository, it tells hibernate it is a DAO class and treat it as DAO class. Means it makes the unchecked exceptions (thrown from DAO methods) eligible for translation into Spring DataAccessException.

@Service : This tells hibernate it is a Service class where you will have @Transactional etc Service layer annotations so hibernate treats it as a Service component.

Plus @Service is advance of @Component. Assume the bean class name is CustomerService, since you did not choose XML bean configuration way so you annotated the bean with @Component to indicate it as a Bean. So while getting the bean object CustomerService cust = (CustomerService)context.getBean("customerService"); By default, Spring will lower case the first character of the component – from 'CustomerService' to 'customerService'. And you can retrieve this component with name 'customerService'. But if you use @Service annotation for the bean class you can provide a specific bean name by

@Service("AAA")
public class CustomerService{

and you can get the bean object by

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

Différence entre @Component, @Service et @Repository

La différence majeure entre ces stéréotypes est qu'ils sont utilisés pour une classification différente.

Dans une application à plusieurs niveaux, nous aurons différentes couches comme la présentation, le service, l'entreprise, l'accès aux données, etc. Lorsqu'une classe doit être annotée pour la détection automatique par Spring, nous devrions utiliser le stéréotype respectif comme ci-dessous.

@Component - générique et peut être utilisé à travers l'application.
@Service - annote les classes au niveau de la couche de service.
@Repository - annote des classes à la couche de persistance, qui agira comme référentiel de base de données.

Si techniquement ils vont être identiques alors pourquoi avons-nous besoin de les utiliser au niveau des couches différentes. Pourquoi ne pas utiliser la même chose à tous les niveaux. Par exemple, si nous utilisons @Service dans toutes les couches, tous les beans seront instanciés et aucun problème. Il y a une différence mineure, par exemple considérons @Repository .

Le postprocesseur recherche automatiquement tous les traducteurs d'exception (implémentations de l'interface PersistenceExceptionTranslator) et conseille tous les beans marqués avec l'annotation @Repository afin que les traducteurs @Repository puissent intercepter et appliquer la traduction appropriée sur les exceptions @Repository .

Similaire à ce qui précède, à l'avenir, Spring peut choisir d'ajouter de la valeur pour @Service , @Controller et @Repository fonction de leurs conventions de superposition. Pour cette caractéristique supplémentaire, il vaut mieux respecter la convention et les utiliser en ligne avec les couches.

Outre ce qui précède, en ce qui concerne la détection automatique, l'injection de dépendances pour BeanDefinition @Component , @Service , @Repository et @Controller sont identiques.


Explanation of stereotypes :

  • @Service - Annotate all your service classes with @Service. This layer knows the unit of work. All your business logic will be in Service classes. Generally methods of service layer are covered under transaction. You can make multiple DAO calls from service method, if one transaction fails all transactions should rollback.
  • @Repository - Annotate all your DAO classes with @Repository. All your database access logic should be in DAO classes.
  • @Component - Annotate your other components (for example REST resource classes) with component stereotype.
  • @Autowired - Let Spring auto-wire other beans into your classes using @Autowired annotation.

@Componentest un stéréotype générique pour tout composant géré par Spring. @Repository,, @Serviceet @Controllersont des spécialisations de @Componentcas d'utilisation plus spécifiques, par exemple dans les couches de persistance, de service et de présentation, respectivement.

A répondu à l'origine here .


@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 tous @Repository , @Service ou @Controller sont annotés avec @Component . Alors, pouvons-nous utiliser seulement @Component pour tous les composants pour l'analyse automatique? Oui, vous le pouvez, et Spring analysera automatiquement tous vos composants avec @Component annoté.

Cela fonctionne bien, mais ce n'est pas une bonne pratique, pour des @Repository de lisibilité, vous devez toujours déclarer @Repository , @Service ou @Controller pour une couche spécifiée afin de rendre votre code plus lisible.





annotations