Een beknopte handleiding voor Spring @Value

1. Overzicht

In deze korte tutorial gaan we dat doen kijk eens naar de @Waarde Lente annotatie.

Deze annotatie kan worden gebruikt voor het injecteren van waarden in velden in door Spring beheerde bonen, en kan worden toegepast op het parameterniveau van het veld of de constructor / methode.

2. Instellen van de applicatie

Om verschillende soorten gebruik voor deze annotatie te beschrijven, moeten we een eenvoudige configuratieklasse voor de Spring-applicatie configureren.

Van nature, we hebben een eigenschappenbestand nodig om de waarden te definiëren die we willen injecteren met de @Waarde annotatie. En dus moeten we eerst een @PropertySource in onze configuratieklasse - met de bestandsnaam van het eigenschappenbestand.

Laten we het eigenschappenbestand definiëren:

value.from.file = Waarde verkregen van het bestand priority = high listOfValues ​​= A, B, C

3. Gebruiksvoorbeelden

Als een eenvoudig en meestal nutteloos voorbeeld kunnen we alleen "tekenreekswaarde" vanuit de annotatie in het veld injecteren:

@Value ("stringwaarde") private String stringValue;

De ... gebruiken @PropertySource annotatie stelt ons in staat om te werken met waarden uit eigenschappenbestanden met de @Waarde annotatie.

In het volgende voorbeeld krijgen we Waarde verkregen uit het bestand toegewezen aan het veld:

@Value ("$ {value.from.file}") private String valueFromFile;

We kunnen ook de waarde van systeemeigenschappen met dezelfde syntaxis instellen.

Laten we aannemen dat we een systeemeigenschap hebben gedefinieerd met de naam systemValue:

@Value ("$ {systemValue}") private String systemValue;

Er kunnen standaardwaarden worden opgegeven voor eigenschappen die mogelijk niet zijn gedefinieerd. Hier de waarde sommige standaard zal worden geïnjecteerd:

@Value ("$ {unknown.param: some default}") private String someDefault;

Als dezelfde eigenschap is gedefinieerd als een systeemeigenschap en in het eigenschappenbestand, wordt de systeemeigenschap toegepast.

Stel dat we een eigendom hadden prioriteit gedefinieerd als een systeemeigenschap met de waarde Systeemeigenschap en gedefinieerd als iets anders in het eigenschappenbestand. De waarde zou zijn Systeemeigenschap:

@Value ("$ {priority}") private String prioritySystemProperty;

Soms moeten we een heleboel waarden injecteren. Het zou handig zijn om ze te definiëren als door komma's gescheiden waarden voor de enkele eigenschap in het eigenschappenbestand of als een systeemeigenschap en om ze in een array te injecteren.

In de eerste sectie hebben we door komma's gescheiden waarden gedefinieerd in de listOfValues van het eigenschappenbestand, dus de matrixwaarden zouden zijn ["A", "B", "C"]:

@Value ("$ {listOfValues}") private String [] valuesArray;

4. Geavanceerde voorbeelden met SpEL

We kunnen ook SpEL-uitdrukkingen gebruiken om de waarde te krijgen.

Als we een systeemeigenschap hebben met de naam prioriteit, dan wordt de waarde ervan toegepast op het veld:

@Value ("# {systemProperties ['prioriteit']}") private String spelValue;

Als we de systeemeigenschap niet hebben gedefinieerd, is de nul waarde wordt toegekend.

Om dit te voorkomen, kunnen we een standaardwaarde opgeven in de SpEL-expressie. We krijgen sommige standaard waarde voor het veld als de systeemeigenschap niet is gedefinieerd:

@Value ("# {systemProperties ['unknown']?: 'Some default'}") private String spelSomeDefault;

Verder kunnen we een veldwaarde van andere bonen gebruiken. Stel dat we een boon hebben met de naam SomeBean met een veld eenWaarde gelijk aan 10. Dan, 10 wordt toegewezen aan het veld:

@Value ("# {someBean.someValue}") privé Geheel getal someBeanValue;

We kunnen eigenschappen manipuleren om een Lijst met waarden, hier een lijst met stringwaarden A, B en C:

@Value ("# {'$ {listOfValues}'. Split (',')}") privé Lijstwaardenlijst;

5. Met behulp van @Waarde Met Kaarten

We kunnen ook de @Waarde annotatie om een Kaart eigendom.

Eerst moeten we de eigenschap definiëren in de {sleutel waarde' } formulier in ons eigenschappenbestand:

valuesMap = {key1: '1', key2: '2', key3: '3'}

Merk op dat de waarden in de Kaart moet tussen enkele aanhalingstekens staan.

Nu kunnen we deze waarde uit het eigenschappenbestand injecteren als een Kaart:

@Value ("# {$ {valuesMap}}") privé Map valuesMap;

Als we het nodig hebben om de waarde van een specifieke sleutel te krijgen in de Kaart, alles wat we hoeven te doen is voeg de naam van de sleutel toe aan de uitdrukking:

@Value ("# {$ {valuesMap} .key1}") privé Geheel getal waardenMapKey1;

Als we niet zeker weten of het Kaart bevat een bepaalde sleutel, we moeten kiezen een veiligere expressie die geen uitzondering genereert, maar de waarde instelt op nul als de sleutel niet wordt gevonden:

@Value ("# {$ {valuesMap} ['unknownKey']}") privé Geheel getal unknownMapKey;

We kunnen ook stel standaardwaarden in voor de eigenschappen of sleutels die mogelijk niet bestaan:

@Value ("# {$ {unknownMap: {key1: '1', key2: '2'}}}") privékaart unknownMap; @Value ("# {$ {valuesMap} ['unknownKey']?: 5}") privé Geheel getal unknownMapKeyWithDefaultValue;

Kaart vermeldingen kunnen ook worden gefilterd voor injectie.

Laten we aannemen dat we alleen die vermeldingen nodig hebben waarvan de waarden groter zijn dan één:

@Value ("# {$ {valuesMap}.? [Value> '1']}") privé Map valuesMapFiltered;

We kunnen ook de @Waarde annotatie bij injecteer alle huidige systeemeigenschappen:

@Value ("# {systemProperties}") privé kaart systemPropertiesMap;

6. Met behulp van @Waarde Met Constructor Injection

Wanneer we de @Waarde annotatie, we zijn niet beperkt tot een veldinjectie. We kunnen het ook samen met constructor injectie gebruiken.

Laten we dit in de praktijk bekijken:

@Component @PropertySource ("classpath: values.properties") public class PriorityProvider {privé Stringprioriteit; @Autowired openbare PriorityProvider (@Value ("$ {prioriteit: normal}") Stringprioriteit) {this.priority = prioriteit; } // standaard getter}

In het bovenstaande voorbeeld injecteren we een prioriteit direct in onze PriorityProvider‘S constructor.

Houd er rekening mee dat we ook een standaardwaarde bieden voor het geval de eigenschap niet wordt gevonden.

7. Met behulp van @Waarde Met Setter-injectie

Analoog aan de constructor-injectie, we kunnen ook gebruiken @Waarde met setter injectie.

Laten we kijken:

@Component @PropertySource ("classpath: values.properties") openbare klasse CollectionProvider {privé Lijstwaarden = nieuwe ArrayList (); @Autowired public void setValues ​​(@Value ("# {'$ {listOfValues}'. Split (',')}") Lijstwaarden) {this.values.addAll (waarden); } // standaard getter}

We gebruiken de SpEL-expressie om een ​​lijst met waarden in de setValues methode.

8. Conclusie

In dit artikel hebben we de verschillende mogelijkheden onderzocht om het @Waarde annotatie met eenvoudige eigenschappen die in het bestand zijn gedefinieerd, met systeemeigenschappen en met eigenschappen die zijn berekend met SpEL-expressies.

Zoals altijd is de voorbeeldtoepassing beschikbaar in het GitHub-project.