Spring Core-annotaties

Dit artikel maakt deel uit van een reeks: • Spring Core Annotations (huidig ​​artikel) • Spring Web Annotations

• Spring Boot-annotaties

• Annotaties voor voorjaarsplanning

• Spring Data-annotaties

• Spring Bean-annotaties

1. Overzicht

We kunnen de mogelijkheden van Spring DI-engine benutten met behulp van de annotaties in het org.springframework.beans.factory.annotation en org.springframework.context.annotation pakketjes.

We noemen deze vaak 'Spring-kernannotaties' en we zullen ze in deze tutorial bespreken.

2. DI-gerelateerde annotaties

2.1. @Autowired

We kunnen de @Autowired naar markeer een afhankelijkheid die Spring gaat oplossen en injecteren. We kunnen deze annotatie gebruiken met een constructor, setter of veldinjectie.

Constructor injectie:

klasse auto {motor motor; @Autowired Car (Engine engine) {this.engine = engine; }}

Setter injectie:

klasse auto {motor motor; @Autowired void setEngine (Engine engine) {this.engine = engine; }}

Veldinjectie:

klasse auto {@Autowired Engine engine; }

@Autowired heeft een boolean argument genoemd verplicht met een standaardwaarde van waar. Het stemt het gedrag van de lente af wanneer het geen geschikte boon vindt om te bedraden. Wanneer waar, wordt er een uitzondering gegenereerd, anders is er niets bedraad.

Merk op dat als we constructor-injectie gebruiken, alle constructor-argumenten verplicht zijn.

Vanaf versie 4.3 hoeven we constructors niet te annoteren met @Autowired expliciet tenzij we ten minste twee constructeurs declareren.

Bezoek onze artikelen over voor meer informatie @Autowired en constructor injectie.

2.2. @Boon

@Boon markeert een fabrieksmethode die een springboon instantieert:

@Bean Engine engine () {retourneer nieuwe Engine (); }

Spring noemt deze methoden wanneer een nieuw exemplaar van het retourtype vereist is.

De resulterende boon heeft dezelfde naam als de fabrieksmethode. Als we het anders willen noemen, kunnen we dat doen met de naam of de waarde argumenten van deze annotatie (het argument waarde is een alias voor het argument naam):

@Bean ("engine") Engine getEngine () {retourneer nieuwe Engine (); }

Merk op dat alle methoden die zijn geannoteerd met @Boon moet binnen zijn @Configuratie klassen.

2.3. @Kwalificatie

We gebruiken @Kwalificatie samen met @Autowired naar geef de bean-id of de bean-naam op we willen gebruiken in dubbelzinnige situaties.

De volgende twee bonen implementeren bijvoorbeeld dezelfde interface:

klasse Fiets werktuig Voertuig {} klasse Auto werktuig Voertuig {}

Als Spring een Voertuig bean, het eindigt met meerdere overeenkomende definities. In dergelijke gevallen kunnen we de naam van een boon expliciet opgeven met behulp van de @Kwalificatie annotatie.

Constructor-injectie gebruiken:

@Autowired Biker (@Qualifier ("fiets") Voertuig voertuig) {this.vehicle = voertuig; }

Setter-injectie gebruiken:

@Autowired void setVehicle (@Qualifier ("fiets") Voertuig voertuig) {this.vehicle = voertuig; }

Alternatief:

@Autowired @Qualifier ("fiets") void setVehicle (Voertuig voertuig) {this.vehicle = voertuig; }

Veldinjectie gebruiken:

@Autowired @Qualifier ("fiets") Voertuig voertuig;

Lees dit artikel voor een meer gedetailleerde beschrijving.

2.4. @Verplicht

@Verplicht op setter-methoden om afhankelijkheden te markeren die we via XML willen vullen:

@Required void setColor (String kleur) {this.color = color; }

Anders, BeanInitializationException zal worden gegooid.

2.5. @Waarde

We kunnen gebruiken @Waarde voor het injecteren van eigenschapswaarden in bonen. Het is compatibel met constructor, setter en field injection.

Constructor injectie:

Motor (@Value ("8") int cylinderCount) {this.cylinderCount = cylinderCount; }

Setter injectie:

@Autowired void setCylinderCount (@Value ("8") int cylinderCount) {this.cylinderCount = cylinderCount; }

Alternatief:

@Value ("8") void setCylinderCount (int cylinderCount) {this.cylinderCount = cylinderCount; }

Veldinjectie:

@Value ("8") int cylinderCount;

Het injecteren van statische waarden is natuurlijk niet zinvol. Daarom kunnen we gebruiken placeholder tekenreeksen in @Waarde om waarden te bedraden gedefinieerd in externe bronnen, bijvoorbeeld in .eigendommen of .yaml bestanden.

Laten we het volgende aannemen .eigendommen het dossier:

engine.fuelType = benzine

We kunnen de waarde van injecteren engine.fuelType met het volgende:

@Value ("$ {engine.fuelType}") String fuelType;

We kunnen gebruiken @Waarde zelfs met SpEL. Meer geavanceerde voorbeelden zijn te vinden in ons artikel over @Waarde.

2.6. @Hangt af van

We kunnen deze annotatie gebruiken om Spring te maken initialiseer andere bonen vóór de geannoteerde. Gewoonlijk is dit gedrag automatisch, gebaseerd op de expliciete afhankelijkheden tussen bonen.

We hebben alleen deze annotatie nodig wanneer de afhankelijkheden impliciet zijn, bijvoorbeeld het laden van JDBC-stuurprogramma's of initialisatie van statische variabelen.

We kunnen gebruiken @Hangt af van op de afhankelijke klasse die de namen van de afhankelijkheidsbonen specificeert. De annotatie's waarde argument heeft een array nodig die de namen van de dependency bean bevat:

@DependsOn ("engine") klasse Auto implementeert Voertuig {}

Als alternatief, als we een boon definiëren met de @Boon annotatie, moet de fabrieksmethode worden geannoteerd met @Hangt af van:

@Bean @DependsOn ("brandstof") Engine engine () {retourneer nieuwe Engine (); }

2.7. @Lui

We gebruiken @Lui wanneer we onze boon lui willen initialiseren. Standaard creëert Spring gretig alle singleton beans bij het opstarten / opstarten van de toepassingscontext.

Er zijn echter gevallen waarin we moeten een bean maken wanneer we daarom vragen, niet bij het opstarten van de applicatie.

Deze annotatie gedraagt ​​zich anders, afhankelijk van waar we deze precies plaatsen. We kunnen het op:

  • een @Boon geannoteerde bean factory-methode, om de methodeaanroep te vertragen (vandaar het maken van de bonen)
  • een @Configuratie klasse en alles bevat @Boon methoden zullen worden beïnvloed
  • een @Component class, wat geen @Configuratie klasse, zal deze boon lui worden geïnitialiseerd
  • een @Autowired constructor, setter of veld, om de afhankelijkheid zelf lui te laden (via proxy)

Deze annotatie heeft een argument met de naam waarde met de standaardwaarde van waar. Het is handig om het standaardgedrag te negeren.

Bijvoorbeeld bonen markeren om gretig te worden geladen wanneer de algemene instelling lui is, of specifiek configureren @Boon methoden om gretig te laden in een @Configuratie klasse gemarkeerd met @Lui:

@Configuration @Lazy klasse VehicleFactoryConfig {@Bean @Lazy (false) Engine engine () {retourneer nieuwe Engine (); }}

Bezoek dit artikel voor meer informatie.

2.8. @Opzoeken

Een methode geannoteerd met @Opzoeken vertelt Spring om een ​​instantie van het retourtype van de methode te retourneren wanneer we deze aanroepen.

Gedetailleerde informatie over de annotatie is te vinden in dit artikel.

2.9. @Primair

Soms moeten we meerdere bonen van hetzelfde type definiëren. In deze gevallen zal de injectie niet succesvol zijn omdat Spring geen idee heeft welke boon we nodig hebben.

We zagen al een optie om met dit scenario om te gaan: alle bedradingspunten markeren met @Kwalificatie en specificeer de naam van de vereiste boon.

Meestal hebben we echter een specifieke boon nodig en zelden de andere. We kunnen gebruiken @Primair om dit geval te vereenvoudigen: if we markeren de meest gebruikte boon met @Primair het wordt gekozen op ongeschikte injectiepunten:

@Component @ Primaire klasse Auto voert voertuig uit {} @Componentklasse Fiets implementeert voertuig {} @Componentklasse Bestuurder {@Autowired Voertuig voertuig; } @Component class Biker {@Autowired @Qualifier ("bike") Voertuig voertuig; }

In het vorige voorbeeld Auto is het primaire voertuig. Daarom in de Bestuurder klasse injecteert Spring een Auto Boon. Natuurlijk, in de Fietser bean, de waarde van het veld voertuig zal een ... zijn Fiets object omdat het gekwalificeerd is.

2.10. @Scope

We gebruiken @Scope om de reikwijdte van een @Component klas of een @Boon definitie. Het kan beide zijn singleton, prototype, verzoek, sessie, globalSession of een aangepast bereik.

Bijvoorbeeld:

@Component @Scope ("prototype") class Engine {}

3. Contextconfiguratie-aantekeningen

We kunnen de toepassingscontext configureren met de annotaties die in deze sectie worden beschreven.

3.1. @Profiel

Als we de lente willen gebruik een @Component klas of een @Boon methode alleen wanneer een specifiek profiel actief is, kunnen we het markeren met @Profiel. We kunnen de naam van het profiel configureren met de waarde argument van de annotatie:

@Component @Profile ("sportDay") klasse Fietswerktuigen Voertuig {}

In dit artikel leest u meer over profielen.

3.2. @Importeren

We kunnen gebruiken specifiek @Configuratie klassen zonder componentscanning met deze annotatie. We kunnen die lessen voorzien @Importeren‘S waarde argument:

@Import (VehiclePartSupplier.class) klasse VehicleFactoryConfig {}

3.3. @ImportResource

Wij kunnen XML-configuraties importeren met deze annotatie. We kunnen de XML-bestandslocaties specificeren met de locaties argument, of met zijn alias, de waarde argument:

@Configuration @ImportResource ("classpath: /annotations.xml") klasse VehicleFactoryConfig {}

3.4. @PropertySource

Met deze annotatie kunnen we definieer eigenschappenbestanden voor applicatie-instellingen:

@Configuration @PropertySource ("classpath: /annotations.properties") klasse VehicleFactoryConfig {}

@PropertySource maakt gebruik van de Java 8-functie voor herhalende annotaties, wat betekent dat we er meerdere keren een klasse mee kunnen markeren:

@Configuration @PropertySource ("classpath: /annotations.properties") @PropertySource ("classpath: /vehicle-factory.properties") class VehicleFactoryConfig {}

3.5. @PropertySources

We kunnen deze annotatie gebruiken om meerdere te specificeren @PropertySource configuraties:

@Configuration @PropertySources ({@PropertySource ("classpath: /annotations.properties"), @PropertySource ("classpath: /vehicle-factory.properties")}) class VehicleFactoryConfig {}

Merk op dat we sinds Java 8 hetzelfde kunnen bereiken met de functie voor herhalende annotaties zoals hierboven beschreven.

4. Conclusie

In dit artikel zagen we een overzicht van de meest voorkomende Spring-kernannotaties. We hebben gezien hoe je bean-bedrading en toepassingscontext configureert, en hoe je klassen markeert voor het scannen van componenten.

Zoals gewoonlijk zijn de voorbeelden beschikbaar op GitHub.

De volgende » Spring Web-annotaties