Eigenschaften mit Spring und Spring Boot

Übersicht

Dieses Tutorial zeigt, wie Eigenschaften in Spring über Java configuration und @PropertySource eingerichtet und verwendet werden.

Wir werden auch sehen, wie Eigenschaften im Spring Boot funktionieren.

Registrieren Sie eine Eigenschaftendatei über Anmerkungen

Spring 3.1 führt auch die neue Annotation @PropertySource als praktischen Mechanismus zum Hinzufügen von Eigenschaftsquellen zur Umgebung ein.,

Wir können diese Anmerkung in Verbindung mit der Anmerkung @Configuration verwenden:

@Configuration@PropertySource("classpath:foo.properties")public class PropertiesWithJavaConfig { //...}

Eine weitere sehr nützliche Methode zum Registrieren einer neuen Eigenschaftendatei ist die Verwendung eines Platzhalters, mit dem wir zur Laufzeit dynamisch die richtige Datei auswählen können:

@PropertySource({ "classpath:persistence-${envTarget:mysql}.properties"})...

2.1. Definieren mehrerer Eigenschaftsstandorte

Die @ PropertySource-Annotation ist gemäß Java 8-Konventionen wiederholbar., Wenn wir Java 8 oder höher verwenden,können wir diese Annotation verwenden, um mehrere Eigenschaftsstandorte zu definieren:

Natürlich können wir auch die Annotation @PropertySources verwenden und ein Array von @PropertySource angeben. Dies funktioniert in jeder unterstützten Java-Version, nicht nur in Java 8 oder höher:

In beiden Fällen ist es erwähnenswert, dass im Falle einer Kollision des Eigenschaftsnamens der letzte gelesene Quellcode Vorrang hat.,

Verwenden/Einfügen von Eigenschaften

Das Einfügen einer Eigenschaft mit der Annotation @Value ist unkompliziert:

@Value( "${jdbc.url}" )private String jdbcUrl;

Wir können auch einen Standardwert für die Eigenschaft angeben:

@Value( "${jdbc.url:aDefaultUrl}" )private String jdbcUrl;

Der neue PropertySourcesPlaceholderConfigurer, der im Frühjahr 3.1 hinzugefügt wurde, löst die Platzhalter ${…} innerhalb der Bean definition Eigenschaftswerte und @Value Anmerkungen.,

Schließlich können wir den Wert einer Eigenschaft mithilfe der Umgebungs-API ermitteln:

@Autowiredprivate Environment env;...dataSource.setUrl(env.getProperty("jdbc.url"));

Eigenschaften mit Spring Boot

Bevor wir auf erweiterte Konfigurationsoptionen für Eigenschaften eingehen, sollten wir uns die neuen Eigenschaften ansehen Unterstützung im Spring Boot.

Im Allgemeinen erfordert diese neue Unterstützung im Vergleich zu Standard Spring weniger Konfiguration, was natürlich eines der Hauptziele von Boot ist.

4.1. Anwendung.,eigenschaften: Die Standardeigenschaftsdatei

Boot wendet ihre typische Konvention über den Konfigurationsansatz auf Eigenschaftendateien an. Dies bedeutet, dass wir einfach einen Antrag stellen können.Eigenschaftendatei in unserem Verzeichnis src / main / resources, und es wird automatisch erkannt. Wir können dann alle geladenen Eigenschaften wie gewohnt injizieren.

Durch die Verwendung dieser Standarddatei müssen wir also keine PropertySource explizit registrieren oder sogar einen Pfad zu einer Eigenschaftendatei angeben.,

Wir können auch eine andere Datei zur Laufzeit konfigurieren, wenn wir eine Umgebungseigenschaft benötigen:

java -jar app.jar --spring.config.location=classpath:/another-location.properties

Ab Spring Boot 2.3 können wir auch Platzhalterspeicherorte für Konfigurationsdateien angeben.

Zum Beispiel können wir die Feder einstellen.config.location Eigenschaft zu config/*/:

java -jar app.jar --spring.config.location=config/*/

Auf diese Weise sucht Spring Boot nach Konfigurationsdateien, die dem config/*/ – Verzeichnismuster außerhalb unserer JAR-Datei entsprechen. Dies ist praktisch, wenn wir mehrere Quellen von Konfigurationseigenschaften haben.

Seit Version 2.4.,0, Spring Boot unterstützt die Verwendung von Multi-Document-Eigenschaftendateien, ähnlich wie YAML:

baeldung.customProperty=defaultValue#---baeldung.customProperty=overriddenValue

Beachten Sie, dass für Eigenschaftendateien der Drei-Striche-Notation ein Kommentarzeichen (#) vorangestellt ist.

4.2. Umgebungsspezifische Eigenschaftendatei

Wenn wir auf verschiedene Umgebungen abzielen müssen, gibt es einen integrierten Mechanismus dafür im Boot.

Wir können einfach eine Anwendungsumgebung definieren.Eigenschaftendatei im Verzeichnis src / main / resources und legen Sie dann ein Spring-Profil mit demselben Umgebungsnamen fest.,

Wenn wir beispielsweise eine „Staging“ – Umgebung definieren, müssen wir ein Staging-Profil und dann Application-Staging definieren.Eigenschaft.

Diese env-Datei wird geladen und hat Vorrang vor der Standard-Eigenschaftendatei. Beachten Sie, dass die Standarddatei weiterhin geladen wird, nur dass bei einer Eigenschaftskollision die umgebungsspezifische Eigenschaftendatei Vorrang hat.

4.3. Testspezifische Eigenschaftendatei

Möglicherweise müssen wir auch andere Eigenschaftswerte verwenden, wenn unsere Anwendung getestet wird.,

Spring Boot erledigt dies für uns, indem wir während eines Testlaufs in unserem Verzeichnis src/test/resources nachsehen. Auch hier sind die Standardeigenschaften weiterhin normal injizierbar, werden jedoch bei einer Kollision von diesen überschrieben.

4.4. Die @ TestPropertySource Annotation

Wenn wir mehr granulare Kontrolle über Testeigenschaften benötigen, können wir die @TestPropertySource Annotation verwenden.,

Dadurch können wir Testeigenschaften für einen bestimmten Testkontext festlegen und Vorrang vor den Standardeigenschaftsquellen haben:

Wenn wir keine Datei verwenden möchten, können wir Namen und Werte direkt angeben:

Einen ähnlichen Effekt erzielen wir auch mit dem Eigenschaftsargument der Annotation @SpringBootTest:

4.5. Hierarchische Eigenschaften

Wenn wir Eigenschaften haben, die gruppiert sind, können wir die Annotation @ConfigurationProperties, die diese Eigenschaftshierarchien in Java-Objektdiagramme abbildet.,

Nehmen wir einige Eigenschaften, die zum Konfigurieren einer Datenbankverbindung verwendet werden:

database.url=jdbc:postgresql:/localhost:5432/instancedatabase.username=foodatabase.password=bar

Und verwenden Sie dann die Anmerkung, um sie einem Datenbankobjekt zuzuordnen:

Spring Boot wendet seinen Konventionskonfigurationsansatz erneut an und ordnet sie automatisch zwischen Eigenschaftsnamen und ihren entsprechenden Feldern zu. Alles, was wir liefern müssen, ist das Eigenschaftspräfix.

Wenn Sie tiefer in die Konfigurationseigenschaften eintauchen möchten, schauen Sie sich unseren ausführlichen Artikel an.

4.6. Alternative: YAML-Dateien

Spring unterstützt auch YAML-Dateien.,

Für testspezifische, umgebungsspezifische und Standardeigenschaftsdateien gelten dieselben Benennungsregeln. Der einzige Unterschied ist die Dateierweiterung und eine Abhängigkeit von der SnakeYAML-Bibliothek in unserem Klassenpfad.,Die folgende Eigenschaftendatei:

database.url=jdbc:postgresql:/localhost:5432/instancedatabase.username=foodatabase.password=barsecret: foo

ist gleichbedeutend mit der folgenden YAML-Datei:

database: url: jdbc:postgresql:/localhost:5432/instance username: foo password: barsecret: foo

Es ist auch erwähnenswert, dass YAML-Dateien die @PropertySource-Annotation nicht unterstützen, wenn wir diese Annotation verwenden müssen, würde sie uns auf die Verwendung einer Eigenschaftendatei beschränken.

Ein weiterer bemerkenswerter Punkt ist, dass Spring Boot in Version 2.4.0 die Art und Weise geändert hat, wie Eigenschaften aus YAML-Dateien mit mehreren Dokumenten geladen werden., Zuvor basierte die Reihenfolge, in der sie hinzugefügt wurden, auf der Reihenfolge der Profilaktivierung. Mit der neuen Version folgt das Framework jedoch denselben Bestellregeln, für die wir zuvor angegeben haben .Eigenschaftendateien; Eigenschaften, die in der Datei niedriger deklariert sind, überschreiben diese einfach höher.

Zusätzlich können in dieser Version Profile aus profilspezifischen Dokumenten nicht mehr aktiviert werden, wodurch das Ergebnis klarer und vorhersehbarer wird.

4.7. Importieren zusätzlicher Konfigurationsdateien

Vor Version 2.4.,0, Spring Boot erlaubt einschließlich zusätzlicher Konfigurationsdateien mit dem Spring.config.lage und Frühling.config.zusätzliche Standorteigenschaften, aber sie hatten bestimmte Einschränkungen. Zum Beispiel mussten sie vor dem Starten der Anwendung definiert werden (als Umgebungs-oder Systemeigenschaften oder unter Verwendung von Befehlszeilenargumenten), da sie zu Beginn des Prozesses verwendet wurden.

In der genannten Version können wir die Feder verwenden.config.eigenschaft innerhalb der Anwendung importieren.eigenschaften oder Anwendung.yml-Datei auf einfache Weise zusätzliche Dateien enthalten., Diese Eigenschaft unterstützt einige interessante Funktionen:

• Hinzufügen mehrerer Dateien oder Verzeichnisse
• Die Dateien können entweder aus dem Klassenpfad oder aus einem externen Verzeichnis geladen werden
• angibt, ob der Startvorgang fehlschlagen sollte, wenn eine Datei nicht gefunden wird, oder wenn es sich um eine optionale Datei
• Import extensionless files

Sehen wir uns ein gültiges Beispiel an:

Hinweis: Hier haben wir diese Eigenschaft nur aus Gründen der Übersichtlichkeit mit Zeilenumbrüchen formatiert.

Spring behandelt Importe als neues Dokument, das unmittelbar unterhalb der Importanmeldung eingefügt wird.

4.8., Eigenschaften aus Befehlszeilenargumenten

Neben der Verwendung von Dateien können wir Eigenschaften direkt in der Befehlszeile übergeben:

java -jar app.jar --property="value"

Wir können dies auch über Systemeigenschaften tun, die vor dem Befehl-jar und nicht danach bereitgestellt werden:

java -Dproperty.name="value" -jar app.jar

4.9. Eigenschaften aus Umgebungsvariablen

Spring Boot erkennt auch Umgebungsvariablen und behandelt sie als Eigenschaften:

export name=valuejava -jar app.jar

4.10., Randomisierung von Eigenschaftswerten

Wenn wir keine deterministischen Eigenschaftswerte wünschen, können wir RandomValuePropertySource verwenden, um die Werte von Eigenschaften randomisieren:

random.number=${random.int}random.long=${random.long}random.uuid=${random.uuid}

4.11. Zusätzliche Arten von Eigenschaftsquellen

Spring Boot unterstützt eine Vielzahl von Eigenschaftsquellen und implementiert eine durchdachte Reihenfolge, um ein vernünftiges Überschreiben zu ermöglichen. Es lohnt sich, die offizielle Dokumentation zu konsultieren, die über den Umfang dieses Artikels hinausgeht.,

Konfiguration mit rohen Beans-der PropertySourcesPlaceholderConfigurer

Neben den praktischen Methoden zum Abrufen von Eigenschaften in Spring können wir die Eigenschaftskonfigurations-Bean auch manuell definieren und neu erstellen.

Die Arbeit mit dem PropertySourcesPlaceholderConfigurer gibt uns die volle Kontrolle über die Konfiguration, mit dem Nachteil, ausführlicher und die meiste Zeit unnötig zu sein.,

Mal sehen, wie wir diese Bean mithilfe der Java-Konfiguration definieren können:

Eigenschaften in Eltern-Kind-Kontexten

Diese Frage stellt sich immer wieder: Was passiert, wenn unsere Webanwendung einen Eltern-und einen untergeordneten Kontext hat? Der übergeordnete Kontext kann einige gemeinsame Kernfunktionen und Beans und dann einen (oder mehrere) untergeordnete Kontexte enthalten, die möglicherweise servletspezifische Beans enthalten.

Was ist in diesem Fall der beste Weg, um Eigenschaftendateien zu definieren und in diese Kontexte aufzunehmen? Und wie kann man diese Eigenschaften am besten aus dem Frühjahr abrufen?

Wir geben eine einfache Aufschlüsselung.,

Wenn die Datei im übergeordneten Kontext definiert ist:

• @Value funktioniert im untergeordneten Kontext: JA

• @Value funktioniert im übergeordneten Kontext: JA

• Umgebung.getProperty im untergeordneten Kontext: JA

• Umgebung.getProperty im übergeordneten Kontext: JA

Wenn die Datei im untergeordneten Kontext definiert ist:

• @Value funktioniert im untergeordneten Kontext: JA

• @Value funktioniert im übergeordneten Kontext: NEIN

• Umgebung.getProperty im untergeordneten Kontext: JA

• Umgebung.,getProperty im übergeordneten Kontext: NEIN

Dieser Artikel zeigte einige Beispiele für die Arbeit mit Eigenschaften und Eigenschaftendateien im Frühjahr.

Wie immer ist der gesamte Code, der den Artikel unterstützt, auf GitHub verfügbar.