Injizieren von Arrays und Listen aus Spring-Eigenschaftendateien

1. Übersicht

In diesem kurzen Tutorial erfahren Sie, wie Sie Werte aus einer Spring-Eigenschaftendatei in ein Array oder eine Liste einfügen.

2. Standardverhalten

Wir beginnen mit einer einfachen Datei application.properties :

arrayOfStrings=Baeldung,dot,com

Mal sehen, wie sich Spring verhält, wenn wir unseren Variablentyp auf String [] setzen :

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

Wir können sehen, dass Spring korrekt davon ausgeht, dass unser Trennzeichen ein Komma ist, und das Array entsprechend initialisieren.

Wir sollten auch beachten, dass das Injizieren eines Arrays standardmäßig nur dann korrekt funktioniert, wenn wir durch Kommas getrennte Werte haben.

3. Injizieren von Listen

Wenn wir versuchen, eine Liste auf die gleiche Weise einzufügen, erhalten wir ein überraschendes Ergebnis:

@Value("${arrayOfStrings}") private List unexpectedListOfStrings;
@Test void whenContextIsInitialized_thenInjectedListContainsUnexpectedValues() { assertEquals(Collections.singletonList("Baeldung,dot,com"), unexpectedListOfStrings); }

Unsere Liste enthält ein einzelnes Element, das dem Wert entspricht, den wir in unserer Eigenschaftendatei festgelegt haben.

Um eine Liste richtig einzufügen, müssen wir eine spezielle Syntax namens Spring Expression Language (SpEL) verwenden:

@Value("#{'${arrayOfStrings}'.split(',')}") private List listOfStrings;
@Test void whenContextIsInitialized_thenInjectedListContainsExpectedValues() { assertEquals(Arrays.asList("Baeldung", "dot", "com"), listOfStrings); }

Wir können sehen, dass unser Ausdruck mit # beginnt, anstatt mit dem $ , das wir mit @Value gewohnt sind .

Wir sollten auch beachten, dass wir eine Split- Methode aufrufen , die den Ausdruck etwas komplexer macht als eine übliche Injektion.

Wenn wir unseren Ausdruck etwas einfacher halten möchten, können wir unser Eigentum in einem speziellen Format deklarieren:

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

Spring erkennt dieses Format und wir können unsere Liste mit einem etwas einfacheren Ausdruck einfügen:

@Value("#{${listOfStrings}}") private List listOfStringsV2;
@Test void whenContextIsInitialized_thenInjectedListV2ContainsExpectedValues() { assertEquals(Arrays.asList("Baeldung", "dot", "com"), listOfStringsV2); }

4. Verwenden von benutzerdefinierten Trennzeichen

Lassen Sie uns eine ähnliche Eigenschaft erstellen, aber dieses Mal verwenden wir ein anderes Trennzeichen:

listOfStringsWithCustomDelimiter=Baeldung;dot;com

Wie wir beim Injizieren von Listen gesehen haben , können wir einen speziellen Ausdruck verwenden, in dem wir unser gewünschtes Trennzeichen angeben können:

@Value("#{'${listOfStringsWithCustomDelimiter}'.split(';')}") private List listOfStringsWithCustomDelimiter;
@Test void whenContextIsInitialized_thenInjectedListWithCustomDelimiterContainsExpectedValues() { assertEquals(Arrays.asList("Baeldung", "dot", "com"), listOfStringsWithCustomDelimiter); }

5. Injizieren anderer Typen

Schauen wir uns die folgenden Eigenschaften an:

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

Wir können sehen, dass Spring grundlegende Typen sofort unterstützt, sodass wir keine spezielle Analyse durchführen müssen:

@Value("#{'${listOfBooleans}'.split(',')}") private List listOfBooleans; @Value("#{'${listOfIntegers}'.split(',')}") private List listOfIntegers; @Value("#{'${listOfCharacters}'.split(',')}") private List listOfCharacters;
@Test void whenContextIsInitialized_thenInjectedListOfBasicTypesContainsExpectedValues() { assertEquals(Arrays.asList(false, false, true), listOfBooleans); assertEquals(Arrays.asList(1, 2, 3, 4), listOfIntegers); assertEquals(Arrays.asList('a', 'b', 'c'), listOfCharacters); }

Dies wird nur über SpEL unterstützt, daher können wir ein Array nicht auf die gleiche Weise einfügen.

6. Programmgesteuertes Lesen von Eigenschaften

Um Eigenschaften programmgesteuert lesen zu können, müssen wir zuerst die Instanz unseres Umgebungsobjekts abrufen:

@Autowired private Environment environment;

Dann können wir einfach die getProperty- Methode verwenden, um eine Eigenschaft zu lesen, indem wir ihren Schlüssel und den erwarteten Typ angeben :

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

7. Fazit

In diesem kurzen Tutorial haben wir anhand schneller und praktischer Beispiele gelernt, wie Sie Arrays und Listen einfach einfügen können .

Wie immer ist der Code auf GitHub verfügbar.