Spring Boot: Externe Konfigurationen für Spring Boot

Dieses Tutorial erklärt Ihnen die verschiedenen Möglichkeiten, wie Sie externe Konfigurationen für Spring Boot-Anwendungen vornehmen können. Wenn Sie mit Echtzeitumgebungen arbeiten, werden externe Konfigurationen für Spring Boot für die Flexibilität wichtig. Wenn Sie Fragen haben, schreiben Sie diese bitte in den Kommentarbereich.

Spring Boot: Externe Konfigurationen für #SpringBoot http://t.co/tEFQ71UP3w pic.twitter.com/u8rwUB7iJ5

— JavaBeat (@javabeat) 14. August 2015

Anwendungen müssen die Konfiguration ihrer Datenbank speichern, d. h. den Hostnamen der Datenbank, den Namen der Datenbank, den Benutzer der Datenbank, dann gibt es Informationen wie den Hostnamen aller Entitäten, von denen die Anwendung abhängig ist, einige Spring-bezogene Konfigurationsüberschreibungen und so weiter. Die federbezogenen Konfigurationen finden Sie hier Hier.

Beispiel für externe Spring Boot-Konfigurationen

Es gibt mehrere Quellen, aus denen die Konfiguration gelesen werden kann, und die Reihenfolge, in der die Konfigurationseigenschaften überschrieben werden, wird durch bestimmt Frühlingsstiefel. Die Bestellung wie beschrieben Hier ist unten aufgeführt:

  • Kommandozeilenargumente
  • JNDI-Attribute aus java:comp/env
  • Java-Systemeigenschaften (System.getProperties())
  • Betriebssystemumgebungsvariablen
  • Eine RandomValuePropertySource, die nur zufällige Eigenschaften hat.*
  • Profilspezifische Anwendungseigenschaften außerhalb Ihres gepackten JAR (application-{profile}.properties und YAML-Varianten)
  • Profilspezifische Anwendungseigenschaften, verpackt in Ihrem JAR (application-{profile}.properties und YAML-Varianten)
  • Anwendungseigenschaften außerhalb Ihres gepackten JAR (application.properties und YAML-Varianten)
  • In Ihrem JAR verpackte Anwendungseigenschaften (application.properties und YAML-Varianten)
  • @PropertySource-Anmerkungen zu Ihren @Configuration-Klassen
  • Standardeigenschaften (angegeben mit SpringApplication.setDefaultProperties)

In diesem Beitrag zeige ich Ihnen, wie Sie Eigenschaften mithilfe der folgenden Ansätze definieren:

  • Kommandozeilenargumente
  • Profilspezifische Anwendungseigenschaften außerhalb Ihres gepackten JAR (application-{profile}.properties und YAML-Varianten)
  • Profilspezifische Anwendungseigenschaften, verpackt in Ihrem JAR (application-{profile}.properties und YAML-Varianten)
  • Anwendungseigenschaften außerhalb Ihres gepackten JAR (application.properties und YAML-Varianten)
  • In Ihrem JAR verpackte Anwendungseigenschaften (application.properties und YAML-Varianten)
  • Standardeigenschaften (angegeben mit SpringApplication.setDefaultProperties)

Erstellen wir eine einfache SpringBoot-Anwendung, wie in diesem Artikel erläutert. Kurz gesagt, Sie müssten ein Maven-Projekt erstellen und die pom.xml wie unten gezeigt aktualisieren:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.intbittech</groupId>
  <version>1.0</version>
  <name>DocAppAPI</name>
  <description>RESTful API for DocApp</description>
  <artifactId>DocAppAPI</artifactId>
  <properties>
    <java.version>1.8</java.version>
    <start-class>net.javabeat.ExternalConfigApplication</start-class>
  </properties>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.2.3.RELEASE</version>
  </parent>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

Im oben hervorgehobenen Code haben wir die Klasse noch nicht erstellt ExternalConfigApplication. Es wäre der Ausgangspunkt für unsere SpringBoot-Anwendung. Der ExternalConfigApplication Die Klassendefinition ist unten angegeben:

package net.javabeat;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ExternalConfigApplication {

  public static void main(String[] args) throws Exception {
    SpringApplication.run(new Object[] { ExternalConfigApplication.class }, args);
  }

}

Ich werde auch eine Komponentenklasse erstellen ExternalConfigComponent kommentiert mit @Component deren Definition unten aufgeführt ist:

package net.javabeat;

import javax.annotation.PostConstruct;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ExternalConfigComponent {
  private static Logger logger = LoggerFactory.getLogger(ExternalConfigComponent.class);

  //No properties configured yet.

  @PostConstruct
  public void postConstruct(){
    //This is where we are going to print the values of the properties
  }
}

Lassen Sie uns die obige Anwendung wie unten gezeigt kompilieren und ausführen:

C:\Users\Mohamed\workspace\springboot-external-config>mvn clean package
...
...
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.547 s
[INFO] Finished at: 2015-08-09T21:55:30+05:30
[INFO] Final Memory: 22M/218M
[INFO] ------------------------------------------------------------------------

C:\Users\Mohamed\workspace\springboot-external-config>java -jar target\SpringBootExternalConfig-1.0.jar
...
2015-08-09 21:56:29.592  INFO 10444 --- [           main] net.javabeat.ExternalConfigApplication   : Started ExternalConfigApplication in 1.195 seconds (JVM running for 1.675)
...

Sie werden feststellen, dass die Anwendung erfolgreich startet und dann beendet wird. Da es sich hier um eine beliebige andere Java-basierte Befehlszeilenanwendung handelt, wird die Anwendung im Gegensatz zu Webanwendungen ausgeführt und dann beendet.

Eine andere Möglichkeit, die Anwendung auf einmal zu kompilieren und auszuführen, ist die Verwendung des Spring-Boot-Maven-Plugins wie unten gezeigt:

C:\Users\Mohamed\workspace\springboot-external-config>mvn spring-boot:run

Im gesamten Beitrag werde ich das oben genannte Spring-Boot-Maven-Plugin verwenden, um die Anwendung auszuführen.

Beginnen wir nun mit der Erkundung der externen Konfigurationen für Spring Boot-Anwendungen.

Externe Konfigurationen für Spring Boot

Standardeigenschaften (angegeben mit SpringApplication.setDefaultProperties)

SpringApplication hat eine API setDefaultProperties das akzeptiert a Map oder ein Properties Objekt. Ich verbessere das ExternalConfigApplication Klasse, um die Werte für zwei Eigenschaften festzulegen, nämlich: property.one Und property.two Wie nachfolgend dargestellt:

package net.javabeat;

import java.util.HashMap;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ExternalConfigApplication {

  private static final Logger logger = LoggerFactory.getLogger(ExternalConfigApplication.class);

  @Autowired
  private ExternalConfigComponent externalConfigComponent;

  public static void main(String[] args) throws Exception {
    SpringApplication springApplication = new SpringApplication(new Object[] { ExternalConfigApplication.class });

    Map<String, Object> defaultProperties = new HashMap<String, Object>();
    defaultProperties.put("property.one", "Value One");
    defaultProperties.put("property.two", "Value Two");

    springApplication.setDefaultProperties(defaultProperties);

    springApplication.run(args);

  }

}

Greifen wir auf die beiden oben definierten Eigenschaften zu, indem wir sie an zwei Felder in binden ExternalConfigComponent Verwendung der @Value Anmerkung wie unten gezeigt:

package net.javabeat;

import javax.annotation.PostConstruct;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ExternalConfigComponent {
  private static Logger logger = LoggerFactory.getLogger(ExternalConfigComponent.class);

  @Value("${property.one}")
  public String propertyOne;

  @Value("${property.two}")
  public String propertyTwo;

  @PostConstruct
  public void postConstruct(){
    logger.info("Property One: " + propertyOne);
    logger.info("Property Two: " + propertyTwo);
  }

}

Starten wir die obige Anwendung mit dem Spring-Boot-Maven-Plugin wie unten gezeigt:

$ mvn spring-boot:run
...
2015-08-10 01:46:59.530  INFO 4964 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property One: Value One
2015-08-10 01:46:59.530  INFO 4964 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Two: Value Two
...

Unter dem Text, der auf der Konsole gedruckt wird, finden Sie die beiden oben genannten Zeilen mit dem Wert der Eigenschaft.

Anwendungseigenschaften in Ihrem Glas verpackt

Ein anderer Ansatz besteht darin, eine Datei nach Namen zu erstellen application.properties und verpacken Sie es mit Ihrem Glas. Diese Datei enthält die Schlüssel-Wert-Paare für die Eigenschaften. Man kann diese Eigenschaftsdateien mit einem beliebigen Namen benennen, aber der Name muss der Spring-Konfigurationseigenschaft bereitgestellt werden, damit sie diese Datei lesen kann. Standardmäßig sucht Spring nach application.properties Datei. Lasst uns erschaffen application.properties im Ordner src/main/resources wie im Bild unten gezeigt:
Externe Spring Boot-Konfigurationen 1

Und der Inhalt der application.properties ist wie unten gezeigt:

property.two=Value Two Overridden
property.three=Value Three

Es enthält zwei Eigenschaften, nämlich: property.two Und property.three. Sie wundern sich vielleicht über den Namen property.two wiederholt wird. Ja, es wird wiederholt und der Zweck dieser Wiederholung besteht darin, das Überschreiben der Eigenschaften zu zeigen. Die Rangfolge der Eigenschaftsquellen wurde bereits am Anfang aufgeführt und die Standardeigenschaften stehen am Schluss, vorangestellt durch die im JAR gepackte Datei „application.properties“. Sehen wir uns dieses Überschreiben also in Aktion an. Vorher aktualisieren wir die ExternalConfigComponent Klasse mit der neuen Eigenschaft wie unten gezeigt:

package net.javabeat;

import javax.annotation.PostConstruct;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ExternalConfigComponent {
  private static Logger logger = LoggerFactory.getLogger(ExternalConfigComponent.class);

  @Value("${property.one}")
  private String propertyOne;

  @Value("${property.two}")
  private String propertyTwo;

  @Value("${property.three}")
  private String propertyThree;

  @PostConstruct
  public void postConstruct(){
    logger.info("Property One: " + propertyOne);
    logger.info("Property Two: " + propertyTwo);
    logger.info("Property Three: " + propertyThree);
  }

}

Starten wir die Anwendung und sehen uns ihre Ausgabe an:

$ mvn spring-boot:run
...
2015-08-10 02:03:34.572  INFO 920 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property One: Value One
2015-08-10 02:03:34.572  INFO 920 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Two: Value Two Overridden
2015-08-10 02:03:34.573  INFO 920 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Three: Value Three
...

Sie können darüber den Wert von beobachten Eigentum Zwei wurde durch den im angegebenen Wert überschrieben application.properties Datei.

Anwendungseigenschaften außerhalb Ihres verpackten Glases

Oben haben wir gesehen application.properties im Glas verpackt, Jetzt wollen wir sehen, wie application.properties Die Datei kann im Unterverzeichnis /config des aktuellen Verzeichnisses abgelegt werden und Springboot die in dieser Datei definierten Eigenschaften laden lassen. Der Inhalt dieser application.properties-Dateien ist unten aufgeführt:

property.three=Value Three Overridden
property.four=Value Four

Wie üblich gibt es zwei Eigenschaften property.three Und property.four. Sehen wir uns den aktualisierten Code an ExternalConfigComponent unten:

//Add this below along with the other property declarations
@Value("${property.four}")
private String propertyFour;

//Append the below to the postConstruct() method
logger.info("Property Four: " + propertyFour);

Wenn wir die Anwendung ausführen, erhalten wir die folgende Ausgabe:

....
2015-08-14 17:06:13.469  INFO 12624 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property One: Value One
2015-08-14 17:06:13.470  INFO 12624 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Two: Value Two Overridden
2015-08-14 17:06:13.471  INFO 12624 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Three: Value Three Overridden
2015-08-14 17:06:13.472  INFO 12624 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Four: Value Four
...

In den oben hervorgehobenen Zeilen werden Sie feststellen, dass die in der definierte Eigenschaft application.properties Die im Jar definierte Datei wurde durch die application.properties überschrieben, die außerhalb des Jar im Unterverzeichnis /config definiert ist.

Profilspezifische Anwendungseigenschaften, verpackt in Ihrem Glas

Wir können mehrere Werte für eine Eigenschaft haben, abhängig von der Umgebung, in der die Anwendung ausgeführt wird, z. B. Entwicklungsumgebung oder Produktionsumgebung. Um diese Funktion zu unterstützen, verfügt Springboot über ein Konzept namens Profile. Man kann ein Profil mit dem Namen „local“ für die lokale Umgebung, dann „dev“ für die Entwicklungsumgebung usw. erstellen. Daher lauten die Namen der Eigenschaftendateien nun application-local.properties bzw. application-dev.properties.

Das Profil kann durch Festlegen des Profilnamens in der Spring-Eigenschaft ausgewählt werden spring.profiles.active. Wir können diesen Wert mit einem der hier definierten Ansätze festlegen und würden diesen Ansatz verwenden, um den Wert über die Befehlszeile festzulegen. Aber bevor wir das zeigen, wollen wir uns den Inhalt ansehen application-local.properties:

property.four=Value Four Overridden
property.five=Value Five

Lassen Sie uns das aktualisieren ExternalConfigComponent um die neue Immobilie unterzubringen property.five mit dem folgenden Code:

//Add this below along with the other property declarations
@Value("${property.five}")
private String propertyFive;

//Append the below to the postConstruct() method
logger.info("Property Five: " + propertyFive);

Lassen Sie uns die Anwendung mit dem folgenden Befehl ausführen: mvn spring-boot:run -Dspring.profiles.active=local. Nachdem die Anwendung erfolgreich ausgeführt wurde, sehen Sie die folgende Ausgabe:

...
2015-08-14 17:37:29.348  INFO 8760 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property One: Value One
2015-08-14 17:37:29.348  INFO 8760 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Two: Value Two Overridden
2015-08-14 17:37:29.348  INFO 8760 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Three: Value Three Overridden
2015-08-14 17:37:29.348  INFO 8760 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Four: Value Four Overridden
2015-08-14 17:37:29.348  INFO 8760 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Five: Value Five
...

Man merkt, dass die Immobilie property.four von dem /config/application.properties wurde überschrieben von application-local.properties und auch das neue Anwesen property.five bereitgestellt durch die neuen Eigenschaftendateien.

Profilspezifische Anwendungseigenschaften außerhalb Ihres verpackten Glases

So wie wir es gesehen haben application.properties Wenn sie im JAR und außerhalb des JAR in einem Unterverzeichnis abgelegt werden, können wir dasselbe mit profilspezifischen Anwendungseigenschaften tun. Lassen Sie uns application-local.properties mit den folgenden Daten erstellen und im zuvor erstellten Unterverzeichnis /config speichern:

property.five=Value Five Overridden
property.six=Value Six

Und im Folgenden finden Sie die Aktualisierungen des ExternalConfigComponent:

//Add this below along with the other property declarations
@Value("${property.six}")
private String propertySix;

//Append the below to the postConstruct() method
logger.info("Property Six: " + propertySix);

Lassen Sie uns die Anwendung mit dem folgenden Befehl ausführen: mvn spring-boot:run -Dspring.profiles.active=local. Nachdem die Anwendung erfolgreich ausgeführt wurde, sehen Sie die folgende Ausgabe:

...
015-08-14 17:51:59.469  INFO 11564 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Five: Value Five Overridden
2015-08-14 17:51:59.469  INFO 11564 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Six: Value Six
..

Sie können die beiden oben genannten Zeilen neben anderen Zeilen in der Ausgabe sehen, nachdem Sie das Programm ausgeführt haben. Also die application-local.properties Die Datei im Unterverzeichnis /config hat die Datei überschrieben property.five definiert in der application-local.properties verpackt im Glas.

Kommandozeilenargumente

Der Wert für diese Eigenschaften wird beim Starten der Anwendung über die Befehlszeile übergeben. Ich werde zwei Eigenschaften nach Namen konfigurieren: property.six Und property.seven und binde sie an unsere ExternalConfigComponent Klasse wie unten gezeigt:

//Add this below along with the other property declarations
@Value("${property.seven}")
private String propertySeven;

//Append the below to the postConstruct() method
logger.info("Property Seven: " + propertySeven);

Versuchen wir, die Anwendung zu starten, indem wir die Werte für die beiden oben genannten Konfigurationseigenschaften übergeben, wie unten gezeigt:

C:\Users\Mohamed\workspace\springboot-external-config>mvn spring-boot:run -Dspring.profiles.active=local -Dproperty.six="Value Six Overridden" -Dproperty.seven="Value Seven"
...
2015-08-14 19:24:23.430  INFO 5584 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Six: Value Six Overridden
2015-08-14 19:24:23.430  INFO 5584 --- [lication.main()] net.javabeat.ExternalConfigComponent     : Property Seven: Value Seven
...

Sie können die Werte der Konfigurationseigenschaften (oben hervorgehoben) sehen, die neben anderen Ausgaben auf der Konsole gedruckt werden, und auch den Wert für sehen property.six wurde durch den als Befehlszeilenargument übergebenen Wert überschrieben.

Damit sind wir am Ende des Artikels angelangt. Wir haben Ihnen verschiedene Möglichkeiten gezeigt, wie wir Eigenschaften einrichten können Frühlingsstiefel und auch, wie die Reihenfolge/Priorität der Quellen die in verschiedenen Eigenschaftsquellen definierten Werte überschreibt. Wenn Sie Fragen dazu haben Externe Konfigurationen für Spring Bootschreiben Sie es bitte in den Kommentarbereich.

Der vollständige Code kann über Github abgerufen werden Hier. Wenn Sie den vollständigen Code ausführen möchten, müssen Sie den folgenden Befehl verwenden: mvn spring-boot:run -Dspring.profiles.active=local -Dproperty.six="Value Six Overridden" -Dproperty.seven="Value Seven".

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen