[JAVA] Spring Boot Externe Einstellungspriorität

Überblick

--Übersetzte das Dokument über die Priorität des Einstellungswerts der externen Konfiguration von Spring Boot 2.2.0.M4 ins Japanische. --Original: Spring Boot-Referenzdokumentation --4.2. Externalisierte Konfiguration

japanische Übersetzung

Externe Einstellungen

Spring Boot kann externalisiert werden, sodass derselbe Anwendungscode in verschiedenen Umgebungen ausgeführt werden kann. Sie können Ihre Einstellungen mithilfe von Eigenschaftendateien, YAML-Dateien, Umgebungsvariablen und Befehlszeilenargumenten externalisieren. Einstellungen können mithilfe der Annotation @Value direkt in die Bean eingefügt werden, auf die über Spring's Environment zugegriffen wird, oder über @ConfigurationProperties an ein strukturiertes Objekt gebunden werden.

Spring Boot verwendet einen speziellen Bestellmechanismus namens PropertySource. Es ermöglicht ein flexibles Überschreiben von Einstellungen.

Die Einstellungen werden in der folgenden Prioritätsreihenfolge angewendet:

  1. Globale Konfigurationseigenschaften von Devtools in Ihrem Home-Verzeichnis (~ /.spring-boot-devtools.properties, wenn devtools aktiv ist).
  2. Testen Sie die Annotation @TestPropertySource.
  3. Testen Sie die Eigenschaftsattribute. Es kann mit @SpringBootTest und Testanmerkungen verwendet werden, um bestimmte Teile der Anwendung zu testen.
  4. Befehlszeilenargumente.
  5. Auf SPRING_APPLICATION_JSON festgelegte Eigenschaften (Inline-JSON, eingebettet in Umgebungsvariablen und Systemeigenschaften).
  6. ServletConfig-Initialisierungsparameter.
  7. ServletContext-Initialisierungsparameter.
  8. Von Java abgeleitetes JNDI-Attribut: comp / env.
  9. Java-Systemeigenschaften (System.getProperties ()).
  10. Betriebssystemumgebungsvariablen
  11. RandomValuePropertySource, die nur zufällig ist. * Eigenschaften.
  12. Anwendungseigenschaften (application- {profile} .properties und YAML), die für ein bestimmtes Profil gelten und nicht in JAR gepackt sind.
  13. Anwendungseigenschaften (application- {profile} .properties und YAML), die in JAR für ein bestimmtes Profil gepackt sind.
  14. Anwendungseigenschaften (application.properties und YAML), die nicht in der JAR gepackt sind.
  15. Anwendungseigenschaften (application.properties und YAML), die in der JAR enthalten sind.
  16. @ PropertySource-Annotation der @ Configuration-Klasse.
  17. Standardeigenschaften (in SpringApplication.setDefaultProperties angegebene Einstellungen).

Original (Englisch)

4.2. Externalized Configuration

Spring Boot lets you externalize your configuration so that you can work with the same application code in different environments. You can use properties files, YAML files, environment variables, and command-line arguments to externalize configuration. Property values can be injected directly into your beans by using the @Value annotation, accessed through Spring’s Environment abstraction, or be bound to structured objects through @ConfigurationProperties.

Spring Boot uses a very particular PropertySource order that is designed to allow sensible overriding of values. Properties are considered in the following order:

  1. Devtools global settings properties on your home directory (~/.spring-boot-devtools.properties when devtools is active).
  2. @TestPropertySource annotations on your tests.
  3. properties attribute on your tests. Available on @SpringBootTest and the test annotations for testing a particular slice of your application.
  4. Command line arguments.
  5. Properties from SPRING_APPLICATION_JSON (inline JSON embedded in an environment variable or system property).
  6. ServletConfig init parameters.
  7. ServletContext init parameters.
  8. JNDI attributes from java:comp/env.
  9. Java System properties (System.getProperties()).
  10. OS environment variables.
  11. A RandomValuePropertySource that has properties only in random.*.
  12. Profile-specific application properties outside of your packaged jar (application-{profile}.properties and YAML variants).
  13. Profile-specific application properties packaged inside your jar (application-{profile}.properties and YAML variants).
  14. Application properties outside of your packaged jar (application.properties and YAML variants).
  15. Application properties packaged inside your jar (application.properties and YAML variants).
  16. @PropertySource annotations on your @Configuration classes.
  17. Default properties (specified by setting SpringApplication.setDefaultProperties).

Funktionsprüfung für Prioritätsreihenfolge

Führen Sie den Beispielcode aus, um die Priorität anzuzeigen.

application.properties

Beschreiben Sie den Einstellungswert in application.properties.

message=Hello, application.properties!

Application.java

package sample;

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

@SpringBootApplication
public class Application {

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

Controller.java

Die Einstellungswertnachricht wird in JSON zurückgegeben.

package sample;

import java.util.HashMap;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Controller {

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

  @RequestMapping("/")
  public HashMap<String, Object> index() {
    return new HashMap<String, Object>() {
      {
        put("message", message);
      }
    };
  }
}

Beispiel, in dem application.properties angewendet wird

Führen Sie den Spring Boot-Server mit dem Befehl java aus.

$ java -jar target/sample.jar

Beim Zugriff auf den Server wird der in application.properties beschriebene Nachrichteneinstellungswert zurückgegeben.

$ curl http://localhost:8080/
{"message":"Hello, application.properties!"}

Beispiel für die Anwendung von Java-Systemeigenschaften

Verwenden Sie -D, um JSON in der Java-Systemeigenschaft spring.application.json anzugeben, und führen Sie den Spring Boot-Server mit dem Befehl java aus.

$ java -Dspring.application.json='{"message":"Hello, Java System properties!"}' -jar target/sample.jar

Beim Zugriff auf den Server wird die in den Java-Systemeigenschaften angegebene Nachrichteneinstellung zurückgegeben.

$ curl http://localhost:8080/
{"message":"Hello, Java System properties!"}

Java-Systemeigenschaften haben Vorrang vor application.properties. Dies liegt daran, dass die 9. und 15. Priorität in der vorherigen Liste höher sind als die 9 .. "9. Java-Systemeigenschaften (System.getProperties ())." "15. In JAR gepackte Anwendungseigenschaften (application- {profile} .properties und YAML)."

Recommended Posts

Spring Boot Externe Einstellungspriorität
Statische Dateizugriffspriorität beim Spring Boot
Fordern Sie Spring Boot heraus
Spring Boot Form
Zusammenfassung der Grundeinstellungen für Spring Boot, Doma2, Gradle
Spring Boot Denken Sie daran
gae + frühlingsstiefel
SPRING BOOT Lernaufzeichnung 01
Frühlingsstiefel + Heroku Postgres
Schreiben von Frühlingsstiefel-Memos (1)
Erster Frühlingsstiefel (DI)
Spring Boot2 Spickzettel
Spring Boot Servlet-Zuordnung
Spring Boot-Lernverfahren
Schreiben von Spring Boot-Memos (2)
[Spring Boot] DataSourceProperties $ DataSourceBeanCreationException
Spring Boot 2.3 Verfügbarkeit von Anwendungen
Spring Boot Tutorials Themen
Mit Spring Boot herunterladen
Nehmen Sie das externe Glas mit Spring boot2 + Maven3 in das Paket auf
[Spring Boot] Umgebungskonstruktion (macOS)
Legen Sie den Kontextparameter in Spring Boot fest
Spring + MyBatis-Verbindungseinstellungsmethode
Versuchen Sie Spring Boot von 0 bis 100.
Generieren Sie mit Spring Boot einen Barcode
Hallo Welt mit Spring Boot
Spring Boot unter Microsoft Azure
Implementieren Sie GraphQL mit Spring Boot
Spring RestTemplate Config Timeout-Einstellung
Beginnen Sie mit Spring Boot
Hallo Welt mit Spring Boot!
Spring Boot 2 Multiprojekt mit Gradle
[Spring Boot] Erstellung von Webanwendungen
Führen Sie LIFF mit Spring Boot aus
SNS-Login mit Spring Boot
Spring Boot Hot Swapping-Einstellungen
[Java] Thymeleaf Basic (Spring Boot)
Einführung in Spring Boot ~ ~ DI ~
Datei-Upload mit Spring Boot
Spring Boot beginnt mit dem Kopieren
CICS-Java-Anwendung ausführen- (4) Spring Boot-App
Spring Boot beginnend mit Docker
Spring Boot + Springfox Springfox-Boot-Starter 3.0.0 Verwendung
Tipps zur Spring Boot DB
Hallo Welt mit Spring Boot
Setzen Sie Cookies mit Spring Boot
[Spring Boot] Einfaches Rezept für den Paging-Prozess
Verwenden Sie Spring JDBC mit Spring Boot
Aufbau der Docker x Spring Boot-Umgebung
Wichtige Änderungen in Spring Boot 1.5
Modul mit Spring Boot hinzufügen
Erste Schritte mit Spring Boot
NoHttpResponseException in Spring Boot + WireMock
[Spring Boot] Senden Sie eine E-Mail
Einstellungen für die Spring Boot-Leistung
Einführung in Spring Boot Teil 1
Versuchen Sie es mit Spring Boot Security
[Java] [Spring] Spring Boot 1.4-> 1.2 Downgrade Hinweis
Versuchen Sie Spring Boot auf dem Mac
Erstellen Sie mit Spring Boot einen Mikrodienst