Vraag Wat is het verschil tussen @Component, @Repository & @Service-annotaties in het voorjaar?


Kan @Component, @Repository en @Service annotaties worden in het voorjaar door elkaar gebruikt of bieden ze een bepaalde functionaliteit naast het optreden als notatie-apparaat?

Met andere woorden, als ik een serviceklasse heb en ik de annotatie wijzig van @Service naar @Component, zal het zich nog steeds op dezelfde manier gedragen?

Of heeft de annotatie ook invloed op het gedrag en de functionaliteit van de klas?


1515
2017-07-26 09:10


oorsprong


antwoorden:


Van Lente-documentatie:

In het voorjaar van 2.0 en later, de @Repository annotatie is een markering voor   elke klasse die de rol of het stereotype vervult (ook bekend als Data   Access Object of DAO) van een repository. Onder het gebruik van deze marker   is de automatische vertaling van uitzonderingen.

Lente 2.5 introduceert verdere stereotype annotaties: @Component,    @Service, en @Controller. @Component is een generiek stereotype voor iedereen   Door de lente beheerd onderdeel. @Repository, @Service, en @Controller zijn   specialisaties van @Component voor meer specifieke use cases, voor   bijvoorbeeld in de persistentie-, service- en presentatie-lagen,   respectievelijk.

Daarom kunt u annoteren uw component klassen met @Component,   maar door ze te annoteren @Repository, @Serviceof @Controller   in plaats daarvan zijn uw klassen beter geschikt voor verwerking door tools   of associëren met aspecten. Bijvoorbeeld deze stereotype annotaties   ideale doelen maken voor puntcodes.

Dus, als u kiest tussen gebruiken @Component of @Service voor   uw servicelaag, @Service is duidelijk de betere keuze. Evenzo   zoals hierboven vermeld, @Repository wordt al ondersteund als een markering voor   automatische uitzonderingsvertaling in uw persistentielaag.

┌────────────┬─────────────────────────────────────────────────────┐
│ Annotation │ Meaning                                             │
├────────────┼─────────────────────────────────────────────────────┤
│ @Component │ generic stereotype for any Spring-managed component │
│ @Repository│ stereotype for persistence layer                    │
│ @Service   │ stereotype for service layer                        │
│ @Controller│ stereotype for presentation layer (spring-mvc)      │
└────────────┴─────────────────────────────────────────────────────┘

1110
2017-08-01 10:20



Zoals veel van de antwoorden al aangeven waarvoor deze annotaties worden gebruikt, concentreren we ons hier op enkele kleine verschillen tussen hen.

Eerst de Gelijkenis 

Het eerste punt dat opnieuw de aandacht verdient, is dat met betrekking tot scan-auto-detectie en afhankelijkheidsinjectie voor BeanDefinition al deze annotaties (tw., @Component, @Service,   @Repository, @Controller) zijn hetzelfde. We kunnen er één op zijn plaats gebruiken   van een ander en kan nog steeds onze weg vinden.


Verschillen tussen @Component, @Repository, @Controller en @Service

@Component

Dit is een algemene stereotype annotatie die aangeeft dat de klasse een veercomponent is.

Wat is er speciaal aan @Component
<context:component-scan> alleen scans @Component en zoekt niet naar @Controller, @Service en @Repository in het algemeen. Ze worden gescand omdat ze zelf zijn geannoteerd @Component.

Kijk maar eens naar @Controller, @Service en @Repository annotatiedefinities:

@Component
public @interface Service {
    ….
}

@Component
public @interface Repository {
    ….
}

@Component
public @interface Controller {
    …
}

Het is dus niet verkeerd om dat te zeggen @Controller, @Service en @Repository zijn speciale soorten @Component annotatie. <context:component-scan> pikt ze op en registreert hun volgende klassen als bonen, net alsof ze zijn geannoteerd met @Component.

Ze worden gescand omdat ze zelf zijn geannoteerd @Component annotatie. Als we onze eigen aangepaste annotatie definiëren en annoteren met @Component, dan wordt het ook gescand met <context:component-scan>


@Repository

Dit is om aan te geven dat de klasse een gegevensrepository definieert.

Wat is er zo speciaal aan @Repository? 

Naast erop te wijzen dat dit een is Op annotatie gebaseerde configuratie, @RepositoryHet is zijn taak om platformspecifieke uitzonderingen op te vangen en deze opnieuw te gooien als een van de verenigde niet-gecontroleerde uitzonderingen van Spring. En hiervoor zijn we voorzien PersistenceExceptionTranslationPostProcessor, die we als volgt in de toepassingscontext van onze lente moeten toevoegen:

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

Deze bean-post-processor voegt een adviseur toe aan elke boon waarmee is geannoteerd @Repository zodat alle platformspecifieke uitzonderingen worden betrapt en vervolgens opnieuw worden weergegeven als een van de ongecontroleerde uitzondering voor gegevenstoegang van Spring.


@Controller

De @Controller annotatie geeft aan dat een bepaalde klasse de rol van controller speelt. De @Controller annotatie fungeert als een stereotype voor de geannoteerde klasse, met vermelding van zijn rol.

Wat is er speciaal aan @Controller? 

We kunnen deze annotatie niet wijzigen met andere soortgelijke tekens @Service of @Repository, ook al zien ze er hetzelfde uit. De coördinator scant de geannoteerde klassen @Controller en detecteert @RequestMapping annotaties binnen hen. We kunnen alleen gebruiken @RequestMapping op @Controller geannoteerde klassen.


@Service

@Services bedrijfslogica en oproepmethode in de repository-laag vasthouden.

Wat is er speciaal aan @Service? 

Afgezien van het feit dat het wordt gebruikt om aan te geven dat het de zakelijke logica vasthoudt, is er geen merkbare specialiteit die deze annotatie biedt, maar wie weet, de lente kan in de toekomst nog wat extra uitzonderlijke toevoegen.


Wat nog meer?

Net zoals hierboven, kan Spring in de toekomst speciale functies toevoegen voor @Service, @Controller en @Repository gebaseerd op hun gelaagdheid conventies. Daarom is het altijd een goed idee om de conventie te respecteren en ze in overeenstemming met lagen te gebruiken.


423
2017-07-24 06:43



Ze zijn bijna hetzelfde - ze betekenen allemaal dat de klas een lenteboon is. @Service, @Repository en @Controller zijn gespecialiseerd @Components. U kunt ervoor kiezen om specifieke acties met hen uit te voeren. Bijvoorbeeld:

  • @Controller bonen worden gebruikt door spring-mvc
  • @Repository bonen komen in aanmerking voor persistentie-uitzonderingsvertaling

Een ander ding is dat je de componenten semantisch toewijst aan verschillende lagen.

Een ding dat @Component biedt u de mogelijkheid om andere annotaties te annoteren en deze vervolgens op dezelfde manier te gebruiken @Service.

Onlangs maakte ik bijvoorbeeld:

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

Dus alle klassen geannoteerd met @ScheduledJob zijn voorjaarsbonen en daarnaast zijn geregistreerd als kwarts banen. U hoeft alleen maar code op te geven die de specifieke annotatie verwerkt.


388
2017-07-26 09:16



@Component is gelijk aan

<bean>

@Service, @Controller, @Repository = {@Component + wat meer speciale functionaliteit}

Dat gemiddelde Service, de controller en de repository zijn functioneel hetzelfde.

De drie annotaties worden gebruikt om te scheiden "Lagen" in je applicatie,

  • Controllers doen zaken als dispatching, doorsturen, servicemogelijkheden bellen enz.
  • Service Hold business Logica, Berekeningen etc.
  • Repository zijn de DAO's (Data Access Objects), ze hebben rechtstreeks toegang tot de database.

Nu kun je je afvragen waarom ze van elkaar scheiden: (ik neem aan dat je AOP-Aspect-Oriented Programming kent)

Stel dat u alleen de activiteit van de DAO-laag wilt monitoren. Je schrijft een klasse Aspect (A klasse) die wat logt voordat en nadat elke methode van je DAO is aangeroepen, je bent in staat om dat te doen met AOP omdat je drie verschillende lagen hebt en niet gemengd bent.

U kunt dus DAO "rond", "voor" of "na" de DAO-methoden loggen. Je zou dat kunnen doen omdat je in de eerste plaats een DAO had. Wat je net hebt bereikt is Scheiding van zorgen of taken.

Stel je voor dat er slechts één annotatie @Controller was, dan zal deze component dispatching, bedrijfslogica en toegang tot de database krijgen met alle gemengde, dus vuile code!

Bovenstaand is een heel gebruikelijk scenario, er zijn veel meer gebruiksmogelijkheden van waarom drie annotaties worden gebruikt.


332
2018-05-23 05:15



In de lente @Component, @Service, @Controller, en @Repository zijn Stereotype-annotaties die worden gebruikt voor:

@Controller: waar jouw verzoek  toewijzing vanaf de presentatiepagina done, d.w.z. Presentatielaag zal niet naar een ander bestand gaan waar het direct naartoe gaat @Controller klasse en controles voor aangevraagd pad in @RequestMapping annotatie die geschreven is voor de methode roept indien nodig.

@Service: Alle bedrijfslogica is hier, d.w.z. Gegevensgerelateerde berekeningen en alles. Deze annotatie van een bedrijfslaag waarin onze gebruiker de persistentiemethode niet rechtstreeks aanroept, dus deze methode zal deze methode gebruiken met deze annotatie. Het vraagt ​​@Repository per verzoek van de gebruiker

@Repository: Dit is de persistentielaag (Data Access Layer) van de toepassing die gegevens uit de database ontving. d.w.z. alle database gerelateerde bewerkingen worden gedaan door de repository.

@Component - Annoteer uw andere componenten (bijvoorbeeld REST-resourceklassen) met een stereotype component.

Geeft aan dat een geannoteerde klasse een "bestanddeel". Dergelijke klassen zijn   beschouwd als kandidaten voor automatische detectie tijdens het gebruik   op annotaties gebaseerde configuratie en classpath-scanning.

Andere class-level annotaties kunnen worden beschouwd als het identificeren van een   component ook, typisch een speciaal soort component: b.v. de   @Repository-annotatie of de @Aspect-annotatie van AspectJ.

enter image description here


188
2018-03-25 08:00



Lente 2.5 introduceert verdere stereotype annotaties: @Component, @Service en @Controller. @Component dient als een generiek stereotype voor elk door Spring beheerd component; overwegende dat @Repository, @Service en @Controller dienen als specialisaties van @Component voor specifiekere gevallen van gebruik (bijvoorbeeld in de persistentie-, service- en presentatie-lagen, respectievelijk). Wat dit betekent, is dat u uw componentklassen kunt annoteren met @Component, maar door ze te annoteren met @Repository, @Service of @Controller, zijn uw klassen beter geschikt voor verwerking door tools of om aspecten te associëren. Deze stereotype annotaties zijn bijvoorbeeld ideale doelen voor puntcodes. Het is natuurlijk ook mogelijk dat @Repository, @Service en @Controller extra semantiek bevatten in toekomstige releases van het Spring Framework. Dus, als u een beslissing neemt tussen het gebruik van @Component of @Service voor uw servicelaag, is @Service duidelijk de betere keuze. Evenzo, zoals hierboven vermeld, wordt @Repository al ondersteund als een markering voor automatische uitzonderingsvertaling in uw persistentielaag.

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

referentie :- Spring-documentatie - Classpath-scanning, beheerde componenten en schrijfconfiguraties met behulp van Java  


59
2018-05-15 12:48



@Component – Indicates a auto scan component.  
@Repository – Indicates DAO component in the persistence layer.  
@Service – Indicates a Service component in the business layer.   
@Controller – Indicates a controller component in the presentation layer.  

Je zult dat allemaal opgemerkt hebben @Repository,@Service of @Controller zijn geannoteerd met @Component. Dus kunnen we gewoon gebruiken @Component voor alle componenten voor automatisch scannen? Ja, dat kan en Spring zal automatisch al uw componenten scannen met geannoteerde @ Component.

Het werkt prima, maar geen goede gewoonte, voor leesbaarheid moet je dit altijd aangeven @Repository,@Service of @Controller voor een opgegeven laag om uw code gemakkelijker leesbaar te maken.


51
2017-12-16 18:10



Gebruik van @Service en @Repository annotaties zijn belangrijk vanuit het oogpunt van databaseverbindingen.

  1. Gebruik @Service voor al uw DB-verbindingen van het webservicetype
  2. Gebruik @Repository voor al uw opgeslagen proc DB-verbindingen

Als u niet de juiste annotaties gebruikt, kunt u COMMAND-uitzonderingen onderdrukken die worden opgeheven door terugdraaibewerkingen. U ziet uitzonderingen tijdens de belastingbelastingtest die betrekking heeft op terugdraaiende JDBC-transacties.


40
2017-11-02 16:05