Spring From the Trenches:Rückgabe der Laufzeitkonfiguration als JSON
Wenn wir die Laufzeitkonfiguration einer Spring-Webanwendung herausfinden müssen, die auf einem Remote-Server bereitgestellt wird, müssen wir die vom Remote-Server gefundene Eigenschaftendatei lesen. Das ist umständlich.
Glücklicherweise gibt es einen besseren Weg. Dieser Blogbeitrag beschreibt, wie wir
- Schreiben Sie die Laufzeitkonfiguration in eine Protokolldatei, wenn unsere Webanwendung gestartet wird.
- Laufzeitkonfiguration als JSON zurückgeben.
Fangen wir an.
Schreiben der Laufzeitkonfiguration in eine Protokolldatei
Wir können die Laufzeitkonfiguration in eine Protokolldatei schreiben, indem wir diesen Schritten folgen:
- Fügen Sie einen toString() hinzu -Methode zu den WebProperties Klasse.
- Fügen Sie einen toString() hinzu -Methode zu den ApplicationProperties Klasse.
- Schreiben Sie die Laufzeitkonfiguration in eine Protokolldatei, wenn unsere Webanwendung gestartet wird.
Lassen Sie uns herausfinden, wie wir diese Schritte abschließen können.
Zuerst , müssen wir einen toString() hinzufügen -Methode zu den WebProperties Klasse und implementieren Sie diese Methode mithilfe von ToStringBuilder Klasse.
Nachdem wir dies getan haben, wird der Quellcode der WebProperties Klasse sieht wie folgt aus:
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public final class WebProperties {
private final String protocol;
private final String serverHost;
private final int serverPort;
@Autowired
public WebProperties(@Value("${app.server.protocol}") String protocol,
@Value("${app.server.host}") String serverHost,
@Value("${app.server.port}") int serverPort) {
checkThatProtocolIsValid(protocol);
this.protocol = protocol;
this.serverHost = serverHost;
this.serverPort = serverPort;
}
private void checkThatProtocolIsValid(String protocol) {
if (!protocol.equalsIgnoreCase("http") && !protocol.equalsIgnoreCase("https")) {
throw new IllegalArgumentException(String.format(
"Protocol: %s is not allowed. Allowed protocols are: http and https.",
protocol
));
}
}
public String getProtocol() {
return protocol;
}
public String getServerHost() {
return serverHost;
}
public int getServerPort() {
return serverPort;
}
@Override
public String toString() {
return new ToStringBuilder(this)
.append("protocol", this.protocol)
.append("serverHost", this.serverHost)
.append("serverPort", this.serverPort)
.toString();
}
}
Zweiter , müssen wir einen toString() hinzufügen -Methode zu den ApplicationProperties Klasse und implementieren Sie sie mithilfe von ToStringBuilder Klasse. Nachdem wir diese Änderungen an den ApplicationProperties vorgenommen haben Klasse sieht der Quellcode wie folgt aus:
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
public final class ApplicationProperties {
private final String name;
private final boolean productionModeEnabled;
private final WebProperties webProperties;
@Autowired
public ApplicationProperties(@Value("${app.name}") String name,
@Value("${app.production.mode.enabled:false}") boolean productionModeEnabled,
WebProperties webProperties) {
this.name = name;
this.productionModeEnabled = productionModeEnabled;
this.webProperties = webProperties;
}
public String getName() {
return name;
}
public boolean isProductionModeEnabled() {
return productionModeEnabled;
}
public WebProperties getWebProperties() {
return webProperties;
}
@Override
public String toString() {
return new ToStringBuilder(this)
.append("name", this.name)
.append("productionModeEnabled", this.productionModeEnabled)
.append("webProperties", this.webProperties)
.toString();
}
}
Dritter , müssen wir beim Start der Anwendung die Laufzeitkonfiguration in die Protokolldatei schreiben. Wir können dies tun, indem wir diesen Schritten folgen:
- Fügen Sie einen statischen finalen Logger hinzu Feld zu ApplicationProperties Klasse und erstellen Sie einen neuen Logger -Objekt mithilfe der LoggerFactory Klasse.
- Fügen Sie ein writeConfigurationToLog() hinzu -Methode zu den ApplicationProperties Klasse und kommentieren Sie sie mit @PostConstruct Anmerkung. Dadurch wird sichergestellt, dass die Methode aufgerufen wird, nachdem die Abhängigkeiten des erstellten Bean-Objekts in sie eingefügt wurden.
- Implementieren Sie writeConfigurationToLog() Methode durch Schreiben der Konfiguration in eine Protokolldatei.
Nachdem wir diese Änderungen an den ApplicationProperties vorgenommen haben Klasse sieht der Quellcode wie folgt aus:
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
@Component
public final class ApplicationProperties {
private static final Logger LOGGER = LoggerFactory.getLogger(ApplicationProperties.class);
private final String name;
private final boolean productionModeEnabled;
private final WebProperties webProperties;
@Autowired
public ApplicationProperties(@Value("${app.name}") String name,
@Value("${app.production.mode.enabled:false}") boolean productionModeEnabled,
WebProperties webProperties) {
this.name = name;
this.productionModeEnabled = productionModeEnabled;
this.webProperties = webProperties;
}
public String getName() {
return name;
}
public boolean isProductionModeEnabled() {
return productionModeEnabled;
}
public WebProperties getWebProperties() {
return webProperties;
}
@Override
public String toString() {
return new ToStringBuilder(this)
.append("name", this.name)
.append("productionModeEnabled", this.productionModeEnabled)
.append("webProperties", this.webProperties)
.toString();
}
@PostConstruct
public void writeConfigurationToLog() {
LOGGER.info("Starting application by using configuration: {}", this);
}
}
Wenn wir unsere Webanwendung starten, sollten wir die folgenden Informationen aus ihrer Protokolldatei finden:
INFO - ApplicationProperties - Starting application by using configuration: net.petrikainulainen.spring.trenches.config.ApplicationProperties@254449bb[ name=Configuration Properties example, productionModeEnabled=false, webProperties=net.petrikainulainen.spring.trenches.config.WebProperties@4e642ee1[ protocol=http, serverHost=localhost, serverPort=8080 ] ]Es ist nicht ratsam, vertrauliche Informationen wie den Benutzernamen des Datenbankbenutzers oder das Kennwort des Datenbankbenutzers in eine Protokolldatei zu schreiben.
Wir können jetzt die Laufzeitkonfiguration unserer Webanwendung aus ihrer Protokolldatei finden. Dies ist eine Verbesserung gegenüber der aktuellen Situation, aber es erleichtert uns das Leben nur, wenn wir die Protokolldatei bereits lesen.
Lassen Sie uns herausfinden, wie wir unser Leben noch einfacher machen können, indem wir eine Controller-Methode implementieren, die die Laufzeitkonfiguration als JSON zurückgibt.
Zurückgeben der Laufzeitkonfiguration als JSON
Wir können eine Controller-Methode implementieren, die die Laufzeitkonfiguration als JSON zurückgibt, indem wir die folgenden Schritte ausführen:
- Erstellen Sie eine Controller-Klasse und kommentieren Sie sie mit @RestController Anmerkung.
- Injizieren Sie die ApplicationProperties -Bean in das erstellte Controller-Bean mithilfe der Konstruktorinjektion.
- Erstellen Sie eine Controller-Methode, die GET-Anforderungen verarbeitet, die an die URL „/config“ gesendet werden, und implementieren Sie sie, indem Sie die ApplicationProperties zurückgeben Objekt.
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
@RestController
final class PropertiesController {
private final ApplicationProperties applicationProperties;
@Autowired
PropertiesController(ApplicationProperties applicationProperties) {
this.applicationProperties = applicationProperties;
}
@RequestMapping(value = "/config", method = RequestMethod.GET)
ApplicationProperties getAppConfiguration() {
return applicationProperties;
}
}
Wenn wir eine GET-Anfrage an die URL „/config“ senden, gibt unsere Controller-Methode den folgenden JSON-Code zurück:
{
"name":"Configuration Properties example",
"productionModeEnabled":false,
"webProperties":{
"protocol":"http",
"serverHost":"localhost",
"serverPort":8080
}
}
Wir sollten nicht jedem erlauben, auf die Konfiguration unserer Anwendung zuzugreifen. Wenn dies eine reale Anwendung wäre, sollten wir sicherstellen, dass nur Administratoren auf diese Informationen zugreifen können. Fahren wir fort und fassen zusammen, was wir aus diesem Blogbeitrag gelernt haben.
Zusammenfassung
Dieser Blogbeitrag hat uns Folgendes gelehrt:
- Wir können die Laufzeitkonfiguration in eine Protokolldatei schreiben, indem wir toString() überschreiben Methoden der Konfigurations-Bean-Klassen und Schreiben der Eigenschaftswerte dieser Beans in eine Protokolldatei, nachdem die Eigenschaftswerte in sie eingefügt wurden.
- Wir können die Laufzeitkonfiguration als JSON zurückgeben, indem wir eine Controller-Methode erstellen, die das „Root“-Configuration-Bean-Objekt zurückgibt.
P.S. Sie können die Beispielanwendung dieses Blogbeitrags von Github erhalten.
