L'annotation Spring @Controller est-elle identique à @Service?
L'annotation Spring est-elle @Controller pareil que @Service?
J'ai une idée de @Controller qui peut être utilisé pour URL mapper et appeler la logique métier.
tandis que @Service utilisé pour annoter la classe de service contenant la logique applicative.
Puis-je utiliser @Controller au lieu de @Service annoter la classe de service?
Non, ils sont assez différents les uns des autres.
Les deux sont des spécialisations différentes de l'annotation @ Component (en pratique, ce sont deux implémentations différentes de la même interface). Elles peuvent donc être découvertes par l'analyse du chemin de classe (si vous le déclarez dans votre configuration XML).
@ Service l'annotation est utilisée dans votre couche de service et annote les classes qui effectuent des tâches de service. Souvent, vous ne l'utilisez pas, mais dans de nombreux cas, vous utilisez cette annotation pour représenter une pratique recommandée. Par exemple, vous pouvez appeler directement une classe DAO pour conserver un objet dans votre base de données, mais cela est horrible. C'est très bien d'appeler une classe de service qui appelle un DAO. C’est une bonne chose d’effectuer le schéma de séparation des préoccupations.
@ Controller L'annotation est une annotation utilisée dans Spring MVC Framework (composant de Spring Framework utilisé pour implémenter une application Web). L'annotation @Controller indique qu'une classe particulière joue le rôle de contrôleur. L'annotation @Controller agit comme un stéréotype pour la classe annotée, indiquant son rôle. Le répartiteur analyse ces classes annotées à la recherche de méthodes mappées et détecte les annotations @RequestMapping.
En regardant l'architecture Spring MVC, vous avez donc une classe DispatcherServlet (que vous déclarez dans votre configuration XML) qui représente un contrôleur frontal qui envoie toute la requête HTTP vers les classes de contrôleur appropriées (annotées par @Controller). Cette classe exécute la logique métier (et peut appeler les services) par sa méthode. Ces classes (ou ses méthodes) sont généralement annotées également avec l'annotation @ RequestMapping qui spécifie quelle requête HTTP est gérée par le contrôleur et par sa méthode.
Par exemple:
@Controller
@RequestMapping("/appointments")
public class AppointmentsController {
private final AppointmentBook appointmentBook;
@Autowired
public AppointmentsController(AppointmentBook appointmentBook) {
this.appointmentBook = appointmentBook;
}
@RequestMapping(method = RequestMethod.GET)
public Map<String, Appointment> get() {
return appointmentBook.getAppointmentsForToday();
}
Cette classe est un contrôleur.
Cette classe gère toute la requête HTTP vers "/ rendez-vous" "dossier" et en particulier la méthode get est la méthode appelée pour traiter toute la requête HTTP GET vers le dossier "/ rendez-vous".
J'espère que maintenant c'est plus clair pour vous.
Si vous regardez les définitions de @Controller, @Service annotations, alors vous constaterez qu’il s’agit d’un type spécial de @Component annotation.
@Component
public @interface Service {
….
}
@Component
public @interface Controller {
…
}
Alors, quelle est la différence?
@ Controller
Le @Controller annotation indique qu'une classe particulière joue le rôle de 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?
Vous ne pouvez pas changer cette annotation avec une autre comme @Service ou @Repository, même s'ils ont le même aspect. Le répartiteur analyse les classes annotées avec @Controller et détecte @RequestMapping annotations en leur sein. Vous ne pouvez utiliser que @RequestMapping sur @Controller classes annotées.
@ Service
@Services détient la logique métier et la méthode d’appel dans la couche référentiel.
Quelle est la particularité de @Service?
Hormis le fait qu’elle est utilisée pour indiquer qu’elle conserve la logique métier, cette annotation ne présente aucune spécialité notable, mais qui sait, le printemps pourrait ajouter des éléments exceptionnels à l’avenir.
Réponse liée: Quelle est la différence entre les annotations @Component, @Repository & @Service au printemps?
Non, @Controller n'est pas la même chose que @Service, bien qu'ils soient tous deux des spécialisations de @Component, ce qui en fait des candidats à la découverte par balayage de classpath. Le @Service L'annotation est utilisée dans votre couche service et @Controller est destiné aux contrôleurs Spring MVC dans votre couche présentation. UNE @Controller aurait généralement un mappage d’URL et serait déclenché par une requête Web.
@Service vs @Controller
@Service: class est une "façade de service métier" (au sens des modèles J2EE principaux), ou quelque chose de similaire.
@Controller: indique qu'une classe annotée est un "contrôleur" (par exemple, un contrôleur Web).
---------- Trouvez des notes utiles sur les stéréotypes majeurs http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/stereotype/Component.html
Composant @interface
@Target(value=TYPE)
@Retention(value=RUNTIME)
@Documented
public @interface Component
Indique qu'une classe annotée est un composant. De telles 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 du balayage des chemins d'accès aux classes.
D'autres annotations au niveau classe peuvent également être considérées comme identifiant un composant, généralement un type de composant spécial: par ex. l'annotation @Repository ou l'annotation @Aspect d'AspectJ.
@ Contrôleur d'interface
@Target(value=TYPE)
@Retention(value=RUNTIME)
@Documented
@Component
public @interface Controller
Indique qu'une classe annotée est un "contrôleur" (par exemple, un contrôleur Web).
Cette annotation sert de spécialisation de @Component, ce qui permet de détecter automatiquement les classes d'implémentation via le balayage de chemin d'accès aux classes. Il est généralement utilisé en combinaison avec des méthodes de gestionnaire annotées basées sur l'annotation RequestMapping.
@ service d'interface
@Target(value=TYPE)
@Retention(value=RUNTIME)
@Documented
@Component
public @interface Service
Indique qu'une classe annotée est un "service", défini à l'origine par Domain-Driven Design (Evans, 2003) comme "une opération proposée en tant qu'interface autonome dans le modèle, sans état encapsulé". Peut également indiquer qu’une classe est une "façade de service métier" (au sens des modèles J2EE principaux), ou quelque chose de similaire. Cette annotation est un stéréotype à usage général et les équipes individuelles peuvent affiner leur sémantique et l'utiliser de manière appropriée.
Cette annotation sert de spécialisation de @Component, ce qui permet de détecter automatiquement les classes d'implémentation via le balayage de chemin d'accès aux classes.
@ référentiel d'interface
@Target(value=TYPE)
@Retention(value=RUNTIME)
@Documented
@Component
public @interface Repository
Indique qu'une classe annotée est un "référentiel", défini à l'origine par Domain-Driven Design (Evans, 2003) en tant que "mécanisme d'encapsulation du stockage, de la récupération et du comportement de recherche émulant une collection d'objets". Les équipes implémentant des modèles J2EE traditionnels tels que "Data Access Object" peuvent également appliquer ce stéréotype aux classes DAO. Il convient toutefois de bien comprendre la distinction entre les référentiels Data Access Object et DDD. Cette annotation est un stéréotype à usage général et les équipes individuelles peuvent affiner leur sémantique et l'utiliser de manière appropriée.
Une classe ainsi annotée est éligible pour la traduction Spring DataAccessException si elle est utilisée avec un PersistenceExceptionTranslationPostProcessor. La classe annotée est également clarifiée quant à son rôle dans l'architecture globale de l'application aux fins de l'outillage, des aspects, etc.
À partir de Spring 2.5, cette annotation sert également de spécialisation de @Component, permettant ainsi la détection automatique des classes d'implémentation via l'analyse de chemin d'accès aux classes.
J'ai déjà répondu à une question similaire ici voici le lien
Non, les deux sont différents.
Les annotations @Service sont utilisées à d'autres fins et @Controller à d'autres fins. En réalité, les annotations Spring @Component, @Service, @Repository et @Controller sont utilisées pour la détection automatique de beans à l'aide de l'analyse de chemin d'accès aux classes dans l'infrastructure Spring, mais cela ne signifie pas que toutes les fonctionnalités sont identiques. @Service: il indique que la classe annotée est un composant de service de la couche de gestion.
@Controller: La classe annotée indique qu'il s'agit d'un composant du contrôleur, principalement utilisé au niveau de la couche de présentation.
Non, vous ne pouvez pas, ils sont différents. Lorsque l'application était déployée, vos mappages de contrôleur seraient borkés par exemple.
Pourquoi voulez-vous quand même, un contrôleur est pas un service, et vice versa.
Du printemps en action
Comme vous pouvez le constater, cette classe est annotée avec @Controller. En soi, @Controller ne fait pas grand chose. Son objectif principal est d'identifier cette classe en tant que composant d'analyse. Etant donné que HomeController est annoté avec @Controller, l’analyse des composants de Spring le détecte automatiquement et crée une instance de HomeController en tant que bean dans le contexte de l’application Spring.
En fait, une poignée d'autres annotations (notamment @Component, @Service et @Repository) remplit une fonction similaire à celle de @Controller. Vous auriez pu annoter de manière tout aussi efficace HomeController avec l'une de ces autres annotations, et cela aurait toujours fonctionné de la même manière. Le choix de @Controller est cependant plus descriptif du rôle de ce composant dans l’application.