Eine Kurzanleitung zu Spring @Value

1. Übersicht

In diesem kurzen Tutorial werfen wir einen Blick auf die Annotation @Value Spring.

Diese Anmerkung kann zum Einfügen von Werten in Felder in Spring-verwalteten Beans verwendet werden und kann auf Feld- oder Konstruktor- / Methodenparameterebene angewendet werden.

2. Einrichten der Anwendung

Um verschiedene Verwendungsarten für diese Anmerkung zu beschreiben, müssen wir eine einfache Konfigurationsklasse für Spring-Anwendungen konfigurieren.

Natürlich benötigen wir eine Eigenschaftendatei , um die Werte zu definieren, die mit der Annotation @Value eingefügt werden sollen . Daher müssen wir zuerst eine @ PropertySource in unserer Konfigurationsklasse definieren - mit dem Namen der Eigenschaftendatei.

Definieren wir die Eigenschaftendatei:

value.from.file=Value got from the file priority=high listOfValues=A,B,C

3. Anwendungsbeispiele

Als einfaches und meist nutzloses Beispiel können wir nur "Zeichenfolgenwerte" aus der Anmerkung in das Feld einfügen:

@Value("string value") private String stringValue;

Mit der Annotation @PropertySource können wir mit Werten aus Eigenschaftendateien mit der Annotation @Value arbeiten .

Im folgenden Beispiel erhalten wir den Wert aus der dem Feld zugewiesenen Datei :

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

Wir können den Wert auch aus Systemeigenschaften mit derselben Syntax festlegen.

Nehmen wir an, wir haben eine Systemeigenschaft namens systemValue definiert :

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

Standardwerte können für Eigenschaften angegeben werden, die möglicherweise nicht definiert sind. Hier wird der Standardwert eingefügt:

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

Wenn dieselbe Eigenschaft als Systemeigenschaft und in der Eigenschaftendatei definiert ist, wird die Systemeigenschaft angewendet.

Angenommen , wir eine Eigenschaft hatte Priorität definiert als Systemeigenschaft mit dem Wert der Systemeigenschaft und ist definiert als etwas anderes in der Eigenschaftsdatei. Der Wert wäre Systemeigenschaft :

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

Manchmal müssen wir eine Reihe von Werten einfügen. Es wäre zweckmäßig, sie als durch Kommas getrennte Werte für die einzelne Eigenschaft in der Eigenschaftendatei oder als Systemeigenschaft zu definieren und in ein Array einzufügen.

Im ersten Abschnitt haben wir in der listOfValues der Eigenschaftendatei durch Kommas getrennte Werte definiert , sodass die Array-Werte ["A", "B", "C"] lauten :

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

4. Erweiterte Beispiele mit SpEL

Wir können auch SpEL-Ausdrücke verwenden, um den Wert zu erhalten.

Wenn wir eine Systemeigenschaft mit dem Namen priority haben, wird ihr Wert auf das Feld angewendet:

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

Wenn wir die Systemeigenschaft nicht definiert haben, wird der Nullwert zugewiesen.

Um dies zu verhindern, können wir im SpEL-Ausdruck einen Standardwert angeben. Wir erhalten einen Standardwert für das Feld, wenn die Systemeigenschaft nicht definiert ist:

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

Darüber hinaus können wir einen Feldwert aus anderen Beans verwenden. Angenommen, wir haben eine Bean namens someBean mit einem Feld someValue gleich 10 . Dann werden dem Feld 10 zugewiesen:

@Value("#{someBean.someValue}") private Integer someBeanValue;

We can manipulate properties to get a List of values, here, a list of string values A, B, and C:

@Value("#{'${listOfValues}'.split(',')}") private List valuesList;

5. Using @Value With Maps

We can also use the @Value annotation to inject a Map property.

First, we'll need to define the property in the {key: ‘value' } form in our properties file:

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

Note that the values in the Map must be in single quotes.

Now we can inject this value from the property file as a Map:

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

If we need to get the value of a specific key in the Map, all we have to do is add the key's name in the expression:

@Value("#{${valuesMap}.key1}") private Integer valuesMapKey1;

If we're not sure whether the Map contains a certain key, we should choose a safer expression that will not throw an exception but set the value to null when the key is not found:

@Value("#{${valuesMap}['unknownKey']}") private Integer unknownMapKey;

We can also set default values for the properties or keys that might not exist:

@Value("#{${unknownMap : {key1: '1', key2: '2'}}}") private Map unknownMap; @Value("#{${valuesMap}['unknownKey'] ?: 5}") private Integer unknownMapKeyWithDefaultValue;

Map entries can also be filtered before injection.

Let's assume we need to get only those entries whose values are greater than one:

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

We can also use the @Value annotation to inject all current system properties:

@Value("#{systemProperties}") private Map systemPropertiesMap;

6. Using @Value With Constructor Injection

When we use the @Value annotation, we're not limited to a field injection. We can also use it together with constructor injection.

Let's see this in practice:

@Component @PropertySource("classpath:values.properties") public class PriorityProvider { private String priority; @Autowired public PriorityProvider(@Value("${priority:normal}") String priority) { this.priority = priority; } // standard getter }

In the above example, we inject a priority directly into our PriorityProvider‘s constructor.

Note that we also provide a default value in case the property isn't found.

7. Using @Value With Setter Injection

Analogous to the constructor injection, we can also use @Value with setter injection.

Let's take a look:

@Component @PropertySource("classpath:values.properties") public class CollectionProvider { private List values = new ArrayList(); @Autowired public void setValues(@Value("#{'${listOfValues}'.split(',')}") List values) { this.values.addAll(values); } // standard getter }

We use the SpEL expression to inject a list of values into the setValues method.

8. Conclusion

In diesem Artikel haben wir die verschiedenen Möglichkeiten untersucht, die Annotation @Value mit einfachen, in der Datei definierten Eigenschaften, mit Systemeigenschaften und mit mit SpEL-Ausdrücken berechneten Eigenschaften zu verwenden.

Wie immer ist die Beispielanwendung im GitHub-Projekt verfügbar.