streamalism.org

1. Introduksjon

I denne raske opplæringen tar vi en titt på vårens avhengighetsinjiseringsstøtte på metodenivå via @Se opp kommentar.

2. Hvorfor @Se opp?

En metode kommentert med @Se opp forteller Spring om å returnere en forekomst av metodens returtype når vi påberoper den.

I hovedsak vil Spring overstyre vår merkede metode og bruke metodens returtype og parametere som argumenter for BeanFactory # getBean.

@Se opp er nyttig for:

• Injisere en prototype-scoped bønne i en singleton bønne (ligner på Forsørger)
• Injisere avhengigheter prosessuelt

Legg også merke til at @Se opp er Java-ekvivalenten til XML-elementet oppslagsmetode.

3. Bruke @Se opp

3.1. Injiserende prototype-scoped Bean Into a Singleton Bean

Hvis vi tilfeldigvis bestemmer oss for å ha en prototype vårbønne, står vi nesten umiddelbart overfor problemet med hvordan vil vår singleton vårbønner få tilgang til disse prototypen vårbønner?

Nå, Forsørger er absolutt en måte, skjønt @Se opp er mer allsidig i noen henseender.

La oss først lage en prototype bønne som vi senere vil injisere i en singletonbønne:

@Component @Scope ("prototype") offentlig klasse SchoolNotification {// ... prototype-scoped state}

Og hvis vi lager en singletonbønne som bruker @Se opp:

@Component public class StudentServices {// ... medlemsvariabler osv. @Lookup public SchoolNotification getNotification () {return null; } // ... getters og setters}

Ved hjelp av @Se opp, kan vi få en forekomst av Skolemelding gjennom vår singleton bønne:

@Test offentlig ugyldig nårLookupMethodCalled_thenNewInstanceReturned () {// ... initialiser kontekst StudentServices først = this.context.getBean (StudentServices.class); StudentServices second = this.context.getBean (StudentServices.class); assertEquals (første, andre); assertNotEquals (first.getNotification (), second.getNotification ()); }

Legg merke til at i Studenttjenester, forlot vi få varsel metode som stubbe.

Dette er fordi Spring overstyrer metoden med et kall til beanFactory.getBean (StudentNotification.class), slik at vi kan la den stå tom.

3.2. Injisere avhengigheter prosessuelt

Fortsatt kraftigere er det imidlertid @Se opp lar oss injisere en avhengighet prosessuelt, noe vi ikke kan gjøre med Forsørger.

La oss forbedre Studentvarsling med noen tilstand:

@Component @Scope ("prototype") offentlig klasse SchoolNotification {@Autowired Grader grader; privat strengnavn; private samlinger; public SchoolNotification (String name) {// ... set fields} // ... getters and setters public String addMark (Integer mark) {this.marks.add (mark); returner this.grader.grade (this.marks); }}

Nå er det avhengig av vårkontekst og også tilleggskontekst som vi vil gi prosessuelt.

Vi kan deretter legge til en metode for Studenttjenester som tar studentdata og vedvarer det:

offentlig abstrakt klasse StudentServices {private Map notes = new HashMap (); @Lookup-beskyttet abstrakt SchoolNotification getNotification (strengnavn); public String appendMark (String name, Ingerger mark) {SchoolNotification notification = notes.computeIfAbsent (name, exist -> getNotification (name))); returvarsel.addMark (merke); }} 

På kjøretid vil Spring implementere metoden på samme måte, med et par ekstra triks.

Vær først oppmerksom på at den kan kalle en kompleks konstruktør, samt injisere andre vårbønner, slik at vi kan behandle Skolemelding litt mer som en vårbevisst metode.

Det gjør dette ved å implementere getSchoolNotification med en samtale til beanFactory.getBean (SchoolNotification.class, navn).

For det andre kan vi noen ganger lage @Se opp-kommentert metode abstrakt, som eksemplet ovenfor.

Ved hjelp av abstrakt er litt finere enn en stubbe, men vi kan bare bruke den når vi ikke gjør detkomponent-skanning eller @Bønne-få til den omkringliggende bønnen:

@Test offentlig ugyldig nårAbstraktGetterMethodInjects_thenNewInstanceReturned () {// ... initialiser kontekst StudentServices services = context.getBean (StudentServices.class); assertEquals ("PASS", services.appendMark ("Alex", 89)); assertEquals ("FAIL", services.appendMark ("Bethany", 78)); assertEquals ("PASS", services.appendMark ("Claire", 96)); }

Med dette oppsettet kan vi legge til våravhengigheter så vel som metodeavhengigheter til Skolemelding.

4. Begrensninger

Til tross for @Se oppAllsidighet, det er noen få bemerkelsesverdige begrensninger:

• @Se opp-noterte metoder, som få varsel, må være konkret når klassen rundt, som Student, er komponentskannet. Dette er fordi komponentskanning hopper over abstrakte bønner.
• @Se opp-merkede metoder fungerer ikke i det hele tatt når klassen rundt @Bønne-fikk til.

Under disse omstendighetene, hvis vi trenger å injisere en prototype bønne i en singleton, kan vi se etter Forsørger som et alternativ.

5. Konklusjon

I denne raske artikkelen lærte vi hvordan og når vi skulle bruke vårens @Se opp kommentar, inkludert hvordan du bruker den til å injisere prototype-scoped bønner i singleton bønner og hvordan du bruker den til å injisere avhengigheter prosessuelt.

All koden som brukes til denne opplæringen, finner du på Github.