Verwenden von application.yml vs application.properties in Spring Boot

1. Übersicht

In Spring Boot wird häufig eine externe Konfiguration verwendet, um unsere Eigenschaften zu definieren. Dadurch können wir denselben Anwendungscode in verschiedenen Umgebungen verwenden.

Wir können Eigenschaftendateien, YAML-Dateien, Umgebungsvariablen und Befehlszeilenargumente verwenden.

In diesem kurzen Tutorial werden die Hauptunterschiede zwischen Eigenschaften und YAML-Dateien untersucht.

2. Eigenschaften Konfiguration

Standardmäßig kann Spring Boot auf Konfigurationen zugreifen, die in einer Datei application.properties festgelegt sind , die ein Schlüsselwertformat verwendet:

spring.datasource.url=jdbc:h2:dev spring.datasource.username=SA spring.datasource.password=password

Hier ist jede Zeile eine einzelne Konfiguration. Daher müssen wir hierarchische Daten ausdrücken, indem wir für unsere Schlüssel dieselben Präfixe verwenden. In diesem Beispiel gehört jeder Schlüssel zu spring.datasource.

2.1. Platzhalter in Eigenschaften

Innerhalb unserer Werte können wir Platzhalter mit der Syntax $ {} verwenden , um auf den Inhalt anderer Schlüssel, Systemeigenschaften oder Umgebungsvariablen zu verweisen.

app.name=MyApp app.description=${app.name} is a Spring Boot application

2.2. Listenstruktur

Wenn wir dieselbe Art von Eigenschaften mit unterschiedlichen Werten haben, können wir die Listenstruktur mit Array-Indizes darstellen:

application.servers[0].ip=127.0.0.1 application.servers[0].path=/path1 application.servers[1].ip=127.0.0.2 application.servers[1].path=/path2 application.servers[2].ip=127.0.0.3 application.servers[2].path=/path3

3. YAML-Konfiguration

3.1. YAML-Format

Neben Java-Eigenschaftendateien können wir auch YAML-basierte Konfigurationsdateien in unserer Spring Boot-Anwendung verwenden. YAML ist ein praktisches Format zum Angeben hierarchischer Konfigurationsdaten .

Nehmen wir nun dasselbe Beispiel aus unserer Eigenschaftendatei und konvertieren es in YAML:

spring: datasource: password: password url: jdbc:h2:dev username: SA

Dies kann besser lesbar sein als die Alternative zur Eigenschaftendatei, da es keine wiederholten Präfixe enthält.

3.2. Listenstruktur

YAML hat ein präziseres Format zum Ausdrücken von Listen:

application: servers: - ip: '127.0.0.1' path: '/path1' - ip: '127.0.0.2' path: '/path2' - ip: '127.0.0.3' path: '/path3'

3.3. Mehrere Profile

Ein Vorteil der Verwendung von YAML besteht darin, dass mehrere Profile in derselben Datei gespeichert werden können. In YAML geben drei Striche den Beginn eines neuen Dokuments an. So können alle Profile in derselben Datei beschrieben werden:

logging file: name: myapplication.log spring: profiles: staging datasource: password: '' url: jdbc:h2:staging username: SA --- spring: profiles: integration datasource: password: 'password' url: jdbc:mysql://localhost:3306/db_integration username: user

In diesem Beispiel haben wir zwei Federabschnitte mit unterschiedlichen Profilen markiert. Außerdem können wir auf Stammebene einen gemeinsamen Satz von Eigenschaften haben. In diesem Fall ist die Eigenschaft logging.file.name in allen Profilen gleich.

3.4. Profile über mehrere Dateien hinweg

Alternativ zu verschiedenen Profilen in derselben Datei können mehrere Profile in verschiedenen Dateien gespeichert werden. Dies ist die einzige verfügbare Methode, wenn Eigenschaftendateien verwendet werden.

Dies erreichen wir, indem wir den Namen des Profils in den Dateinamen einfügen - zum Beispiel application-dev.yml oder application-dev.properties .

4. Spring Boot-Verwendung

Nachdem wir unsere Konfigurationen definiert haben, wollen wir sehen, wie wir darauf zugreifen können.

4.1. Wert Annotation

Wir können die Werte unserer Eigenschaften mithilfe der Annotation @Value einfügen :

@Value("${key.something}") private String injectedProperty;

Hier wird die Eigenschaft key.something über eine Feldinjektion in eines unserer Objekte injiziert.

4.2. Umwelt Abstraktion

Wir können den Wert einer Eigenschaft auch mithilfe der Umgebungs- API ermitteln:

@Autowired private Environment env; public String getSomeKey(){ return env.getProperty("key.something"); } 

4.3. Annotation zu ConfigurationProperties

Schließlich können wir auch die Annotation @ConfigurationProperties verwenden , um unsere Eigenschaften an typsichere strukturierte Objekte zu binden:

@ConfigurationProperties(prefix = "mail") public class ConfigProperties { String name; String description; ...

5. Schlussfolgerung

In diesem Artikel haben wir einige Unterschiede zwischen Eigenschaften und yml Spring Boot-Konfigurationsdateien festgestellt . Wir haben auch gesehen, wie sich ihre Werte auf andere Eigenschaften beziehen können. Schließlich haben wir uns angesehen, wie wir die Werte in unsere Laufzeit einfügen können.

Wie immer sind alle Codebeispiele auf GitHub verfügbar.