Einstieg in Spring Boot, Teil 11 Spring-Anwendungen per Properties konfigurieren

Autor / Redakteur: Dr. Dirk Koller / Stephan Augsten

Properties sind Key-Value-Paare, mit deren Hilfe sich Spring-Anwendungen konfigurieren lassen. Die einfachste Möglichkeit, Properties festzulegen, ist ein Properties-File. Ein solches schauen wir uns im Folgenden genauer an.

Mit einer Properties-Datei lassen sich Spring-Anwendungen verhältnismäßig einfach konfigurieren.
Mit einer Properties-Datei lassen sich Spring-Anwendungen verhältnismäßig einfach konfigurieren.
(Bild: Spring.io)

In einem Properties-File sind Key und Value einfach durch ein Gleichzeichen getrennt. In Spring Boot heißt die Konfigurationsdatei per Konvention application.properties und liegt unter src/main/resources. Typische Beispiele sind das Setzen des Ports oder des Root-Kontexts, unter dem die Anwendung erreichbar ist:

server.port=8081
server.servlet.context-path=/myapp

Mit diesen Angaben in der application.properties-Datei ist die Anwendung unter http://localhost:8081/myapp erreichbar. Spring Boot findet und verwendet diese Properties automatisch.

„Spring Boot“-Tutorial
Bildergalerie mit 16 Bildern

Mit Hilfe der Punkt-Notation lassen sich zusammengehörige Properties durch einen Präfix gruppieren. Im folgenden Beispiel sind url, username und password einer Datenbankverbindung unter dem Präfix database zusammengefasst:

database.url=jdbc:postgresql:/localhost:5432/instance
database.username=postgres
database.password=8dHj7Nds

Properties können alternativ auch im YAML-Format abgelegt werden. Die Datei liegt dann an gleicher Stelle, heißt aber application.yml. Die gleiche Datenbankverbindung – in YAML konfiguriert – sieht wie folgt aus:

database:
   url: jdbc:postgresql:/localhost:5432/instance
   username: postgres
   password: 8dHj7Nds

Das Präfix wird herausgezogen und muss nicht wiederholt werden. Durch die Einrückung ist festgelegt, dass url, username und password zu database gehören. Welche der beiden Varianten man verwendet ist Geschmackssache. Das YAML-Format eignet sich gut für hierarchisch aufgebaute Properties. Es ist ein bisschen aufgeräumter und weniger voluminös, reagiert aber empfindlich auf falsche Einrückungen.

Einbinden von Properties mit @Value

Mit der Annotation @Value lassen sich Werte aus der Properties-Datei in der Anwendung benutzen. Man legt zu diesem Zweck eine Variable an, annotiert diese mit @Value und gibt dahinter in Klammern den Namen der Property mit einer speziellen Syntax (“${}”) an. Im folgenden Beispiel wird eine Anrede in application.properties definiert:

greeting=Sehr geehrte Damen und Herren

Die Einbindung im Java-Code sieht dann folgendermaßen aus:

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

Die Variable greeting ist hier vom Typ String, es lassen sich auf die gleiche Art und Weise aber auch primitive Datentypen einbinden. Der Wert wird dann automatisch in den Datentyp der Variablen konvertiert:

minAge=16   // application.properties@Value("${minAge}")
private int minAge;

Hinter dem Key kann man, durch einen Doppelpunkt getrennt, einen Default-Wert angeben, falls die Property nicht vorhanden ist:

   @Value("${minAge:18}")
   private String minAge;

Da es sich hier um eine Form der Injektion (Field-Injektion) handelt, funktioniert das nur in Komponenten oder Konfigurationen, also mit @Component, @Controller, @Service, @Repository oder @Configuration gekennzeichneten Klassen.

Die anderen Injektionsarten funktionieren genauso, das folgende Codestück zeigt das am Beispiel der Konstruktor-Injektion:

@Controller
public class PersonController {
   private int minAge;   public PersonController(@Value("${minAge}") int minAge) {
      this.minAge = minAge;
   }
   // ...
}

Properties kann man auch an anderer Stelle einbinden, beispielsweise unterstützt @RequestMapping die Syntax. Die Zugriffspfade einer Anwendung können so konfigurierbar gemacht werden:

mypath=/home // application.properties@RequestMapping("${mypath}")
public String home() {
   // ...
   return "home";
}

Weitere Quellen: @PropertySource

Dass Spring Boot überhaupt ein Properties-File aus src/main/resources mit Namen application.properties einliest, ist eine Folge von Spring Boots „Convention over Configuration“-Ansatz. In bestimmten Fällen kann es aber trotzdem notwendig sein, eine Datei mit einem anderen Namen zu verwenden.

Mit Hilfe der Annotation @PropertySource ist das möglich. Im folgenden Beispiel wird eine Datei namens config.properties eingebunden:

@Controller
@PropertySource("classpath:config.properties")
public class PersonController {
   @Value("${greeting}")
   private String greeting;
   // ...
}

Die Datei kann wie oben beschreiben mit @Value ausgelesen werden. Der @PropertySource-Mechanismus hat allerdings einen kleinen Nachteil, er funktioniert nicht mit Properties im YAML-Format. Außerdem muss man dran denken, dass eine eventuell vorhandene application.properties zusätzlich eingelesen und ausgewertet wird.

Mappen von ganzen Objekten: @ConfigurationProperties

Bisher wurden einzelne Config-Werte eingebunden, es gibt aber auch die Möglichkeit, ganze Objekte mit Config-Properties zu mappen. Dazu gruppiert man die betroffenen Properties mit einem Präfix, wie dies oben für die Datenbankverbindung geschehen ist. Alle Properties beginnen hier wieder mit einem database:

database.url=jdbc:postgresql:/localhost:5432/instancedatabase.username=postgresdatabase.password=8dHj7Nds

Passend dazu legen wir eine Klasse an, im Beispiel heißt sie DBProperties, die über zu den Properties passende Membervariablen verfügt. Die Klasse muss außerdem mit Gettern und Settern für die Variablen ausgestattet und mit @ConfigurationProperties annotiert sein. Das prefix-Attribut der Annotation @ConfigurationProperties wird auf database gesetzt:

@Configuration
@ConfigurationProperties(prefix = "database")
public class DBProperties {
   private String url;
   private String username;
   private String password;
   // Getter und Setter
   // ...
}

Dank der @Configuration-Annotation wird die Klasse vom Spring-Container verwaltet, und die Variablen automatisch mit den im Properties-File definierten Variablen befüllt. DBProperties lässt sich dann wie gewohnt mit @Autowired in andere Klassen injizieren und dort verwenden.

„Spring Boot“-Tutorial
Bildergalerie mit 16 Bildern

Die Validierung schlägt hier fehl, die Anwendung verweigert den Start.
Die Validierung schlägt hier fehl, die Anwendung verweigert den Start.
(Bild: Koller)

Besonders schick an @ConfigurationProperties: Die Werte können mit Hilfe von JSR-303 validiert werden. Dazu werden die Variablen mit den gewünschten Constraints versehen und die Klasse zusätzlich mit @Validated annotiert:

@Configuration
@Validated
@ConfigurationProperties(prefix = "database")
public class DBProperties {
   @NotBlank
   private String url;
   private String username;   @Size(min = 10, max = 20)
   private String password;
   // Getter und Setter
   // ...
}

Wenn die Bedingungen nicht erfüllt ist, schlägt der Start der Anwendung fehl. Im nächsten Beitrag der Reihe schauen wir uns Spring-Profile an, auch dabei spielen Properties wieder eine Rolle.

(ID:47327230)

Über den Autor