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

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

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

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

De la documentation de spring :

Dans Spring 2.0 et @Repository ultérieures, l’annotation @Repository est un marqueur pour toute classe remplissant le rôle ou le stéréotype (également appelé object d’access aux 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 conviennent mieux au traitement par des outils ou à des aspects. Par exemple, ces annotations de stéréotypes constituent des cibles idéales pour les points de repère.

Ainsi, si vous choisissez entre @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) │ └────────────┴─────────────────────────────────────────────────────┘ 

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

D’abord la similarité

Le premier point mérite d’être souligné: en ce qui concerne la détection automatique et l’parsing des dépendances pour BeanDefinition, toutes ces annotations (à savoir, @Component, @Service, @Repository, @Controller) sont identiques. Nous pouvons en utiliser un à la place d’un autre et nous pouvons toujours nous 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 Spring.

Quelle est la particularité de @Component
uniquement @Component et ne recherche pas @Controller , @Service et @Repository en général. Ils sont analysés car ils sont annotés avec @Component .

Jetez simplement un coup d’œil aux définitions d’annotation @Controller , @Service et @Repository :

 @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 d’annotation @Component . les récupère et enregistre leurs classes suivantes en tant que beans, comme si elles étaient annotées avec @Component .

Ils sont analysés car ils sont annotés avec @Component annotation @Component . Si nous définissons nos propres annotations personnalisées et les @Component avec @Component , elles seront également analysées avec


@Dépôt

Ceci 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 Annotation , le @Repository de @Repository consiste à intercepter des exceptions spécifiques à la Plate-forme et à les relancer en tant qu’exception unifiée non @Repository de Spring. Et pour cela, nous disposons de PersistenceExceptionTranslationPostProcessor , que nous devons append dans notre contexte d’application Spring comme ceci:

  

Ce post-processeur de bean ajoute un conseiller à tout bean qui est annoté avec @Repository afin que toutes les exceptions spécifiques à la plate-forme soient détectées, puis retransmises comme l’une des exceptions d’access aux données non vérifiées de Spring.


@Manette

L’annotation @Controller indique qu’une classe particulière joue le rôle d’un contrôleur. L’annotation @Controller 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 s’ils ont la même apparence. Le répartiteur parsing les classes annotées avec @Controller et détecte les annotations @RequestMapping en leur sein. Nous ne pouvons utiliser que @RequestMapping sur les classes annotées @Controller .


@Un service

@Services contient la logique métier et la méthode d’appel dans la couche de référentiel.

Quelle est la particularité de @Service?

Mis à part le fait qu’il est utilisé pour indiquer qu’il maintient la logique métier, il n’ya pas de spécialité notable que cette annotation fournit, mais qui sait, Spring peut append d’autres avantages exceptionnels à l’avenir.


Quoi d’autre?

Comme ci-dessus, Spring pourra choisir à l’avenir d’append des fonctionnalités spéciales pour @Service , @Controller et @Repository fonction de leurs conventions de superposition. Il est donc toujours conseillé de respecter la convention et de les utiliser en fonction des calques.

Ils sont presque les mêmes – tous signifient que la classe est une fève de spring. @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 des exceptions de persistance

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

@Component offre la possibilité d’annoter d’autres annotations et de 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 printaniers et, en plus de cela, sont enregistrées en tant que travaux quartz. Vous devez simplement fournir un code qui gère l’annotation spécifique.

@Component est équivalent à

  

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

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

Les trois annotations permettent de séparer les “couches” dans votre application,

  • Les contrôleurs ne font que des tâches telles que l’envoi, la transmission, l’appel de méthodes de service, etc.
  • Service Hold Logic, Calculs etc.
  • Repository sont les DAO (Data Access Objects), ils accèdent directement à la firebase database.

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

Supposons que vous souhaitiez uniquement surveiller l’activité de la couche DAO. Vous allez écrire une classe Aspect (classe A) qui enregistre 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.

Vous pouvez donc vous connecter à DAO “around”, “before” ou “after” aux méthodes DAO. Vous pourriez le faire parce que vous aviez un DAO en premier lieu. Ce que vous venez de réaliser est la séparation des préoccupations ou des tâches.

Imaginez que s’il n’y avait qu’une seule annotation @Controller, alors ce composant aura une répartition, une logique métier et un access à la firebase database tous mélangés, donc du code sale!

Un des scénarios les plus courants est mentionné ci-dessus. Il existe beaucoup plus de cas d’utilisation de trois annotations.

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

@Controller: où le mappage de votre requête à partir de la page de présentation, c’est-à-dire la couche Présentation, n’ira pas à un autre fichier, il va directement à la classe @Controller et vérifie le chemin demandé dans l’annotation @RequestMapping é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 tout. Cette annotation de la couche de gestion dans laquelle notre utilisateur n’appelle pas directement la méthode de persistance appellera cette méthode en utilisant cette annotation. Il demandera @Repository par requête utilisateur

@Repository : Il s’agit de la couche de persistance (Data Access Layer) de l’application utilisée pour extraire des données de la firebase database. c’est-à-dire que toutes les opérations liées à la firebase database 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 ” composant “. Ces classes sont considérées comme des candidats à la détection automatique lors de l’utilisation de la configuration basée sur des annotations et de l’parsing des chemins de classes.

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

entrer la description de l'image ici

Spring 2.5 introduit d’autres annotations de stéréotypes: @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, vos classes sont mieux adaptées au traitement par des outils ou à des aspects. Par exemple, ces annotations de stéréotypes constituent des cibles idéales pour les points de repère. Bien sûr, il est également possible que @Repository, @Service et @Controller contiennent une sémantique supplémentaire dans les futures 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. 

reference: – Documentation Spring – Analyse des chemins de classes, composants gérés et configurations d’écriture utilisant Java

 @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 les @Repository , @Service ou @Controller sont annotés avec @Component . Alors, pouvons-nous utiliser juste @Component pour tous les composants pour l’parsing automatique? Oui, vous pouvez, et Spring parsingra 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 un calque spécifié afin de rendre votre code plus facile à lire.

L’utilisation des annotations @Service et @Repository est importante du sharepoint vue de la connexion à la firebase database.

  1. Utilisez @Service pour tous les types de connexions de votre service Web.
  2. Utilisez @Repository pour toutes vos connexions de firebase database 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 d’effort lié à l’annulation des transactions JDBC.

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

La principale différence 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, telles que la présentation, le service, l’entreprise, l’access aux données, etc.

@Component – générique et peut être utilisé dans toutes les applications.
@Service – annote les classes au niveau de la couche de service.
@Repository@Repository classes à la couche de persistance, qui agira comme référentiel de firebase database.

Si techniquement ils vont être les mêmes alors pourquoi devons-nous les utiliser au niveau des couches différentes. Pourquoi ne pas utiliser le même pour toutes les couches. Par exemple, si nous utilisons @Service dans toutes les couches, tous les beans seront instanciés et aucun problème ne se posera. Il y a une différence mineure, par exemple, @Repository .

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

À l’instar de ce qui précède, Spring pourra choisir à l’avenir d’append de la valeur pour @Service , @Controller et @Repository fonction de leurs conventions de superposition. L’avantage de cette fonctionnalité supplémentaire est de respecter la convention et de les utiliser en ligne avec les calques.

En dehors de ce qui précède, en ce qui concerne la détection automatique, les injections de dépendance pour BeanDefinition @Component , @Service , @Repository , @Controller sont identiques.

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

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

  • Si nous ajoutons le @Component, alors il indique que le rôle de la classe est une classe de composants, cela signifie que c’est une classe composée de logique, mais elle ne dit pas si une classe contenant une logique métier directement cette annotation @Component
  • Si nous ajoutons une annotation @Service, cela indique qu’un rôle de classe est constitué d’une logique métier
  • Si nous ajoutons @Repository au-dessus de la classe, cela indique qu’une classe composée d’une logique de persistance
  • Ici, @Component est 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 @Controller annotation @Service ou @Repositroy ou @Controller par défaut, l’annotation @Component va exister au-dessus de la classe

Dans une application à plusieurs niveaux, nous aurons différentes couches, telles que la présentation, le service, l’entreprise, l’access aux données, etc.

  • @Component – générique et peut être utilisé dans toutes les applications.
  • @Service – annote les classes au niveau de la couche de service.
  • @Controller@Controller classes au niveau des couches de présentation, principalement utilisées dans Spring MVC.
  • @Repository@Repository classes à la couche de persistance, qui agira comme référentiel de firebase database.

Spring fournit quatre types différents d’annotations d’parsing de composants automatiques: @Component , @Service , @Repository et @Controller . Techniquement, il n’y a pas de différence entre elles, mais chaque annotation d’parsing de composant automatique doit être utilisée dans un but spécifique et dans la couche définie.

@Component : Il s’agit d’une annotation de base d’parsing de composant automatique, qui indique que la classe annotée est un composant d’parsing automatique.

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

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

@Repository : Vous devez utiliser cette annotation dans la couche de persistance, cela agit comme un référentiel de firebase database.

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.

Annotez les autres composants avec @Component, par exemple les 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.

@ Composant au spring

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

2.Dans une application multiniveau, nous aurons différentes couches comme la présentation, le service, les affaires, l’access aux données, etc. Lorsqu’une classe doit être annotée pour une détection automatique par Spring, nous devons utiliser le stéréotype correspondant comme ci-dessous.

  • @Component – générique et peut être utilisé dans toutes les applications.
  • @Service – annote les classes au niveau de la couche de service.
  • @Controller@Controller classes au niveau des couches de présentation, principalement utilisées dans Spring MVC.
  • @Repository@Repository classes à la couche de persistance, qui agira comme référentiel de firebase database. Si techniquement ils vont être les mêmes alors pourquoi devons-nous les utiliser au niveau des couches différentes. Pourquoi ne pas utiliser le même pour toutes les couches. Par exemple, si nous utilisons @Service dans toutes les couches, tous les beans seront instanciés et aucun problème ne se posera. Il y a une différence mineure, par exemple, @Repository.

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

  1. À l’instar de ce qui précède, Spring pourra choisir à l’avenir d’append de la valeur pour @Service , @Controller et @Repository fonction de leurs conventions de superposition. À cet avantage supplémentaire de la fonctionnalité, il est préférable de respecter la convention et de les utiliser en ligne avec les calques.
  2. En dehors de ce qui précède, en ce qui concerne la détection automatique , les injections de dépendance pour BeanDefinition @Component , @Service , @Repository , @Controller sont identiques.
  3. Conformément à la documentation Spring: 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é object d’access aux données ou DAO ). Parmi les utilisations de ce marqueur, on trouve la traduction automatique des exceptions, comme décrit à 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 composants avec @Component, mais en les annotant avec @Repository, @Service ou @Controller, vos classes conviennent mieux au traitement par des outils ou à des aspects. Par exemple, ces annotations de stéréotypes constituent des cibles idéales pour les points de repère. Il est également possible que @Repository, @Service et @Controller contiennent une sémantique supplémentaire dans les futures versions de Spring Framework. Ainsi, si vous choisissez entre @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.

Nous pouvons répondre à cela selon la norme java

En vous référant à JSR-330 , qui est désormais pris en charge par Spring, vous ne pouvez utiliser que @Named pour définir un bean (Somehow @Named=@Component ). Donc, selon cette norme, il ne semble pas utile de définir des stéréotypes (comme @Repository , @Service , @Controller ) sur des catégories de beans.

Mais ressortez ces différentes annotations de manière différente pour l’utilisation spécifique, par exemple:

  1. Aidez les développeurs à définir une meilleure catégorie pour les compétences. Cette catégorisation peut devenir utile dans certains cas. (Par exemple, lorsque vous utilisez l’ aspect-oriented , ceux-ci peuvent être un bon candidat pour les pointcuts de pointcuts )
  2. @Repository annotation @Repository appenda des fonctionnalités à votre bean (une traduction automatique des exceptions sur votre couche de persistance bean).
  3. Si vous utilisez Spring MVC, le @RequestMapping ne peut être ajouté qu’aux classes annotées par @Controller .

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

A partir du code source de Spring:

Indique qu’une classe annotée est un “composant”. Ces classes sont considérées comme des candidats à la détection automatique lors de l’utilisation de la configuration basée sur des annotations et de l’parsing des chemins de classes.

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

But de chaque annotation:

1) @Controller -> Classes annotées avec ceci, sont destinées à recevoir une demande du côté client. La première demande provient du servlet du répartiteur, d’où elle 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 à récupérer de la firebase database. Toutes les manipulations avec des données doivent être effectuées dans cette couche.

3) @Repository -> Les classes annotées avec ceci sont destinées à se connecter à la firebase database. Il peut également être considéré 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 envoyées à la couche @Service.

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

Le principal objective de l’utilisation de trois annotations différentes est de fournir une meilleure modularité à l’application Enterprise.

Les @Component Spring @Component , @Service , @Repository et @Controller sont utilisées pour la détection automatique des beans à l’aide de l’parsing du @Repository @Controller dans le framework Spring.

@Component est une annotation générique. La différence de @Service , @Repository , @Controller avec @Component est qu’ils sont des cas particuliers de @Component et utilisés à des fins particulières. La différence ne concerne que la classification.

Pour toutes ces annotations (stéréotypes), techniquement, l’objective principal est le même. Spring parsing et identifie automatiquement toutes les classes annotées avec « @Component , @Service , @Repository , @Controller » et enregistre la définition du bean avec ApplicationContext .

Au spring 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é object d’access aux données ou DAO). Parmi les utilisations de ce marqueur, on trouve la traduction automatique des exceptions, comme décrit à 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. Therefore, you can annotate your component classes with @Component, but by annotating them with @Repository, @Service, or @Controller instead, your classes are more properly suited for processing by tools or associating with aspects. For example, these stereotype annotations make ideal targets for pointcuts. It is also possible that @Repository, @Service, and @Controller may carry additional semantics in future releases of the Spring Framework. Thus, if you are choosing between using @Component or @Service for your service layer, @Service is clearly the better choice. Similarly, as stated above, @Repository is already supported as a marker for automatic exception translation in your persistence layer.

Even if we interchange @Component or @Repository or @service

It will behave the same , but one aspect is that they wont be able to catch some specific exception related to DAO instead of Repository if we use component or @ service

There is no difference between @Component,@Service,@Controller,@Repository. @Component is the Generic annotation to represent the component of our MVC. But there will be several components as part of our MVC application like service layer components, persistence layer components and presentation layer components. So to differentiate them Spring people have given the other three annotations also.

To represent persistence layer components : @Repository

To represent service layer components : @Service

To represent presentation layer components : @Controller

or else you can use @Component for all of them.

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

A @Service to quote spring documentation,

Indicates that an annotated class is a “Service”, originally defined by Domain-Driven Design (Evans, 2003) as “an operation offered as an interface that stands alone in the model, with no encapsulated state.” May also indicate that a class is a “Business Service Facade” (in the Core J2EE patterns sense), or something similar. This annotation is a general-purpose stereotype and individual teams may narrow their semantics and use as appropriate.

If you look at domain driven design by eric evans,

A SERVICE is an operation offered as an interface that stands alone in the model, without encapsulating state, as ENTITIES and VALUE OBJECTS do. SERVICES are a common pattern in technical frameworks, but they can also apply in the domain layer. The name service emphasizes the relationship with other objects. Unlike ENTITIES and VALUE OBJECTS, it is defined purely in terms of what it can do for a client. A SERVICE tends to be named for an activity, rather than an entity—a verb rather than a noun. A SERVICE can still have an abstract, intentional definition; it just has a different flavor than the definition of an object. A SERVICE should still have a defined responsibility, and that responsibility and the interface fulfilling it should be defined as part of the domain model. Operation names should come from the UBIQUITOUS LANGUAGE or be introduced into it. Parameters and results should be domain objects. SERVICES should be used judiciously and not allowed to ssortingp the ENTITIES and VALUE OBJECTS of all their behavior. But when an operation is actually an important domain concept, a SERVICE forms a natural part of a MODEL-DRIVEN DESIGN. Declared in the model as a SERVICE, rather than as a phony object that doesn’t actually represent anything, the standalone operation will not mislead anyone.

and a Repository as per Eric Evans,

A REPOSITORY represents all objects of a certain type as a conceptual set (usually emulated). It acts like a collection, except with more elaborate querying capability. Objects of the appropriate type are added and removed, and the machinery behind the REPOSITORY inserts them or deletes them from the database. This definition gathers a cohesive set of responsibilities for providing access to the roots of AGGREGATES from early life cycle through the end.

@Component This annotation is used on classes to indicate a Spring component.It marks the Java class as a bean or component so that the component-scanning mechanism of Spring can add it into the application context.

@Repository This annotation is used on Java classes that directly access the database.It works as a marker for any class that fulfills the role of repository or Data Access Object.This annotation has an automatic translation feature. For example, when an exception occurs in the @Repository, there is a handler for that exception and there is no need to add a try-catch block.

@Service It marks a Java class that performs some service, such as executing business logic, performing calculations, and calling external APIs. This annotation is a specialized form of the @Component annotation intended to be used in the service layer.

@Controller This annotation is used to indicate the class is a Spring controller.

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.

@Component is a generic stereotype for any Spring-managed component. @Repository , @Service , and @Controller are specializations of @Component for more specific use cases, for example, in the persistence, service, and presentation layers, respectively.

Originally answered here .

@Component – generic and can be used across application. @Service – annotate classes at service layer level. @Repository – annotate classes at persistence layer, which will act as database repository.

In spring framework provides some special type of annotations,called stereotype annotations. These are following:-

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

above declared annotations are special because when we add into xxx-servlet.xml file ,spring will automatically create the object of those classes which are annotated with above annotation during context creation/loading phase.

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

@Component is a generic stereotype for the components managed by Spring @Repository, @Service, and @Controller are @Component specializations for more specific uses:

  • @Repository for persistence
  • @Service for services and transactions
  • @Controller for MVC controllers

Why use @Repository, @Service, @Controller over @Component? We can mark our component classes with @Component, but if instead we use the alternative that adapts to the expected functionality. Our classes are better suited to the functionality expected in each particular case.

A class annotated with “@Repository” has a better translation and readable error handling with org.springframework.dao.DataAccessException. Ideal for implementing components that access data (DataAccessObject or DAO).

An annotated class with “@Controller” plays a controller role in a Spring Web MVC application

An annotated class with “@Service” plays a role in business logic services, example Facade pattern for DAO Manager (Facade) and transaction handling

 @component @controller @Repository @service @RestController 

These are all StereoType annotations. If we placed @controller on top of class. It will not become controller class based on the different layers(components) we can annotate with this annotations but comstackr will not do anything about this just for developer understanding purpose we can choose based on the components which annotations we have to write