Voeg arrays en lijsten toe vanuit Spring Properties Files

1. Overzicht

In deze korte tutorial gaan we leren hoe we waarden in een array of Lijst uit een Spring-eigenschappenbestand.

2. Standaardgedrag

We beginnen met een simpele application.properties het dossier:

arrayOfStrings = Baeldung, punt, com

Laten we eens kijken hoe Spring zich gedraagt ​​als we ons type variabele instellen op Draad[]:

@Value ("$ {arrayOfStrings}") private String [] arrayOfStrings;
@Test void whenContextIsInitialized_thenInjectedArrayContainsExpectedValues ​​() {assertEquals (nieuwe String [] {"Baeldung", "dot", "com"}, arrayOfStrings); }

We kunnen zien dat Spring er correct van uitgaat dat ons scheidingsteken een komma is en de array dienovereenkomstig initialiseert.

We moeten ook opmerken dat het injecteren van een array standaard alleen correct werkt als we door komma's gescheiden waarden hebben.

3. Lijsten injecteren

Als we proberen een Lijst op dezelfde manier krijgen we een verrassend resultaat:

@Value ("$ {arrayOfStrings}") privélijst onverwachteListOfStrings;
@Test void whenContextIsInitialized_thenInjectedListContainsUnexpectedValues ​​() {assertEquals (Collections.singletonList ("Baeldung, dot, com"), onverwachteListOfStrings); }

Onze Lijst bevat een enkel element, dat gelijk is aan de waarde die we hebben ingesteld in ons eigenschappenbestand.

Om een Lijst, moeten we een speciale syntaxis gebruiken genaamd Spring Expression Language (SpEL):

@Value ("# {'$ {arrayOfStrings}'. Split (',')}") privélijst listOfStrings;
@Test void whenContextIsInitialized_thenInjectedListContainsExpectedValues ​​() {assertEquals (Arrays.asList ("Baeldung", "dot", "com"), listOfStrings); }

We kunnen zien dat onze expressie begint met # in plaats van de $ waar we aan gewend zijn @Waarde.

We moeten ook opmerken dat we een beroep doen op een splitsen methode, waardoor de uitdrukking wat complexer is dan een gewone injectie.

Als we onze uitdrukking wat eenvoudiger willen houden, kunnen we ons eigendom in een speciaal formaat aangeven:

listOfStrings = {'Baeldung', 'dot', 'com'}

Spring herkent dit formaat, en we kunnen ons Lijst met een iets eenvoudigere uitdrukking:

@Value ("# {$ {listOfStrings}}") privélijst listOfStringsV2;
@Test void whenContextIsInitialized_thenInjectedListV2ContainsExpectedValues ​​() {assertEquals (Arrays.asList ("Baeldung", "dot", "com"), listOfStringsV2); }

4. Aangepaste scheidingstekens gebruiken

Laten we een vergelijkbare eigenschap maken, maar deze keer gebruiken we een ander scheidingsteken:

listOfStringsWithCustomDelimiter = Baeldung; dot; com

Zoals we hebben gezien bij het injecteren Lijstenkunnen we een speciale uitdrukking gebruiken waarin we ons gewenste scheidingsteken kunnen specificeren:

@Value ("# {'$ {listOfStringsWithCustomDelimiter}'. Split (';')}") privélijst listOfStringsWithCustomDelimiter;
@Test ongeldig whenContextIsInitialized_thenInjectedListWithCustomDelimiterContainsExpectedValues ​​() {assertEquals (Arrays.asList ("Baeldung", "dot", "com"), listOfStringsWithCustomDelimiter); }

5. Andere typen injecteren

Laten we de volgende eigenschappen eens bekijken:

listOfBooleans = false, false, true listOfIntegers = 1,2,3,4 listOfCharacters = a, b, c

We kunnen zien dat Spring standaard basistypen ondersteunt, dus we hoeven geen speciale parsing uit te voeren:

@Value ("# {'$ {listOfBooleans}'. Split (',')}") privélijst listOfBooleans; @Value ("# {'$ {listOfIntegers}'. Split (',')}") privélijst listOfIntegers; @Value ("# {'$ {listOfCharacters}'. Split (',')}") privélijst listOfCharacters;
@Test ongeldig whenContextIsInitialized_thenInjectedListOfBasicTypesContainsExpectedValues ​​() {assertEquals (Arrays.asList (false, false, true), listOfBooleans); assertEquals (Arrays.asList (1, 2, 3, 4), listOfIntegers); assertEquals (Arrays.asList ('a', 'b', 'c'), listOfCharacters); }

Dit wordt alleen ondersteund via SpEL, dus we kunnen geen array op dezelfde manier injecteren.

6. Eigenschappen programmatisch lezen

Om eigenschappen programmatisch te kunnen lezen, moeten we eerst de instantie van our Milieu voorwerp:

@Autowired private omgeving omgeving;

Dan kunnen we gewoon de getProperty methode om een ​​eigenschap te lezen door de sleutel en het verwachte type op te geven:

@Test void whenReadingFromSpringEnvironment_thenPropertiesHaveExpectedValues ​​() {String [] arrayOfStrings = environment.getProperty ("arrayOfStrings", String []. Class); Lijst listOfStrings = (Lijst) environment.getProperty ("arrayOfStrings", List.class); assertEquals (new String [] {"Baeldung", "dot", "com"}, arrayOfStrings); assertEquals (Arrays.asList ("Baeldung", "dot", "com"), listOfStrings); }

7. Conclusie

In deze korte tutorial hebben we geleerd hoe we eenvoudig arrays en kunnen injecteren Lijsts door middel van snelle en praktische voorbeelden.

Zoals altijd is de code beschikbaar op GitHub.