Das Buch „Java in der Cloud. Frühlingsstiefel, Frühlingswolke, Wolkengießerei »

Hallo allerseits! Dieses Buch richtet sich hauptsächlich an Entwickler von Java- und JVM-Maschinen, die nach Möglichkeiten suchen, mit Spring Boot, Spring Cloud und Cloud Foundry in kurzer Zeit bessere Software zu erstellen. Es ist für diejenigen, die bereits das Rauschen um Microservices gehört haben. Möglicherweise haben Sie bereits verstanden, welche stratosphärische Höhe Spring Boot erreicht hat, und Sie sind überrascht, dass Unternehmen heute die Cloud Foundry-Plattform verwenden. Wenn ja, dann ist dieses Buch für Sie.

Auszug. 3. Konfigurationsstil für Anwendungen mit zwölf Faktoren

In diesem Kapitel wird erläutert, wie Sie die Anwendungskonfiguration implementieren.

Definieren Sie eine Reihe von Vokabeln. Wenn es um die Konfiguration in Spring geht, meine ich oft, verschiedene Implementierungen des Anwendungskontexts ApplicationContext in die Spring-Umgebung einzuführen, damit der Container besser versteht, wie Bean-Komponenten verbunden werden. Diese Konfiguration kann als XML-Datei dargestellt werden, die in einem ClassPathXmlApplicationContext bereitgestellt werden muss , oder als Java-Klassen, die mit Anmerkungen versehen sind, die für ein AnnotationConfigApplicationContext- Objekt bereitgestellt werden können. Und natürlich werden wir uns beim Studium der letzten Option auf die Java-Konfiguration beziehen .

In diesem Kapitel werden wir jedoch die Konfiguration überprüfen, wie sie im Manifest der 12-Faktor-Anwendung definiert ist . In diesem Fall handelt es sich um Literalwerte, die sich von einer Umgebung in eine andere ändern können: Es handelt sich um Kennwörter, Ports und Hostnamen oder um Eigenschaftsflags. Die Konfiguration ignoriert die im Code integrierten magischen Konstanten. Das Manifest enthält ein hervorragendes Kriterium für die korrekte Konfiguration: Kann die Anwendungscodebasis jederzeit Open Source sein, ohne wichtige Anmeldeinformationen offenzulegen und zu gefährden? Diese Art der Konfiguration bezieht sich ausschließlich auf die Werte, die von Umgebung zu Umgebung unterschiedlich sind, und gilt beispielsweise nicht für die Verbindung von Spring Beans oder die Konfiguration von Ruby-Routen.

Unterstützung im Frühjahrsrahmen

Im Frühjahr wurde seit dem Aufkommen der PropertyPlaceholderConfigurer- Klasse ein 12-Faktor-Konfigurationsstil unterstützt. Sobald die Instanz definiert ist, werden die Literale in der XML-Konfiguration durch die aus der Datei extrahierten Werte mit der Erweiterung .properties ersetzt. In der Spring-Umgebung wird die PropertyPlaceholderConfigurer- Klasse seit 2003 angeboten. In Spring 2.5 wurde die Unterstützung für den XML-Namespace und gleichzeitig die Unterstützung für die Substitution von Eigenschaften in diesem Bereich eingeführt. Dies ermöglicht das Ersetzen der Definitionen von Bean-Komponenten in der XML-Konfiguration von Literalwerten durch die Werte, die den Schlüsseln in der externen Eigenschaftendatei zugewiesen sind (in diesem Fall in der Datei simple.properties, die im Klassenpfad oder außerhalb der Anwendung angezeigt werden kann).

Die Konfiguration im Stil von 12 Faktoren zielt darauf ab, die Unzuverlässigkeit vorhandener magischer Linien zu beseitigen, dh Werte wie die Adressen von Datenbanken und Konten für die Verbindung zu diesen, Ports usw., die in einer kompilierten Anwendung fest codiert sind. Wenn die Konfiguration außerhalb der Anwendung verschoben wird, kann sie ersetzt werden, ohne auf eine neue Code-Assembly zurückzugreifen.

Klasse PropertyPlaceholderConfigurer

Schauen wir uns ein Beispiel für die Verwendung der PropertyPlaceholderConfigurer-Klasse, der XML-Definitionen von Spring Bean-Komponenten und einer Datei mit der Erweiterung .properties an, die aus den Anwendungsgrenzen herausgenommen wurde. Wir müssen nur den in dieser Eigenschaftendatei verfügbaren Wert drucken. Dies hilft bei der Ausführung des in Beispiel 3.1 gezeigten Codes.

Beispiel 3.1 Eigenschaftendatei: some.properties

configuration.projectName=Spring Framework 

Dies ist die ClassPathXmlApplicationContext-Klasse von Spring. Daher verwenden wir den XML-Namespace aus dem Spring-Kontext und verweisen auf unsere Datei some.properties. Dann verwenden wir Literale in Form von $ {configuration.projectName} in den Definitionen der Bean-Komponenten, und Spring ersetzt sie während der Ausführung durch die Werte aus unserer Eigenschaftendatei (Beispiel 3.2).

Beispiel 3.2. Spring-Konfigurations-XML-Datei

 <context:property-placeholder location="classpath:some.properties"/> (1) <bean class="classic.Application"> <property name="configurationProjectName" value="${configuration.projectName}"/> </bean> 

(1) Klassenpfad: Speicherort, der sich auf die Datei im aktuell kompilierten Codeblock bezieht (.jar, .war usw.). Spring unterstützt viele Alternativen, einschließlich file: und url:, mit denen die Datei außerhalb des Codeblocks existieren kann.

Schauen wir uns abschließend an, wie die Java-Klasse aussieht, mit der all dies zusammengeführt werden kann (Beispiel 3.3).

Beispiel 3.3 Die Java-Klasse, die mit dem Eigenschaftswert konfiguriert werden muss
Paket klassisch;

 import org.apache.commons.logging.LogFactory; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Application { public static void main(String[] args) { new ClassPathXmlApplicationContext("classic.xml"); } public void setConfigurationProjectName(String pn) { LogFactory.getLog(getClass()).info("the configuration project name is " + pn); } } 

Das erste Beispiel verwendet das XML-Format für die Spring Bean-Konfiguration. In Spring 3.0 und 3.1 hat sich die Situation für Entwickler, die die Java-Konfiguration verwenden, erheblich verbessert. Die Value- Annotation und die Environment-Abstraktion wurden in diesen Releases eingeführt.

Abstrakte Umgebung und Wert

Die Umgebungsabstraktion stellt während der Ausführung des Codes seine indirekte Beziehung zur Umgebung dar, in der er ausgeführt wird, und ermöglicht es der Anwendung, die Frage („Welches Zeilentrennzeichen ist line.separator auf dieser Plattform?“) Zu den Eigenschaften der Umgebung zu stellen. Eine Abstraktion dient als Zuordnung von Schlüsseln und Werten. Durch Konfigurieren der PropertySource in der Umgebung können Sie konfigurieren, woher diese Werte gelesen werden. Standardmäßig lädt Spring Systemschlüssel und Umgebungswerte, z. B. line.separator. Sie können Spring anweisen, Konfigurationsschlüssel aus einer Datei in derselben Reihenfolge zu laden, die in früheren Versionen der Spring-Eigenschaftssubstitutionslösung mithilfe der Annotation @PropertySource verwendet werden konnte.

Die Wertanmerkung bietet eine Möglichkeit, Umgebungswerte in Konstruktoren, Setter, Felder usw. einzubetten. Diese Werte können mithilfe der Spring Expression Language oder der Eigenschaftsersetzungssyntax berechnet werden, sofern PropertySourcesPlaceholderConfigurer wie in Beispiel 3.4 registriert ist.

Beispiel 3.4. Registrieren Sie PropertySourcesPlaceholderConfigurer
Paket env;

 import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.PropertySource; import org.springframework.context.support.PropertySourcesPlaceholderConfigurer; import org.springframework.core.env.Environment; import javax.annotation.PostConstruct; (1) @Configuration @PropertySource("some.properties") public class Application { private final Log log = LogFactory.getLog(getClass()); public static void main(String[] args) throws Throwable { new AnnotationConfigApplicationContext(Application.class); } (2) @Bean static PropertySourcesPlaceholderConfigurer pspc() { return new PropertySourcesPlaceholderConfigurer(); } (3) @Value("${configuration.projectName}") private String fieldValue; (4) @Autowired Application(@Value("${configuration.projectName}") String pn) { log.info("Application constructor: " + pn); } (5) @Value("${configuration.projectName}") void setProjectName(String projectName) { log.info("setProjectName: " + projectName); } (6) @Autowired void setEnvironment(Environment env) { log.info("setEnvironment: " + env.getProperty("configuration.projectName")); } (7) @Bean InitializingBean both(Environment env, @Value("${configuration.projectName}") String projectName) { return () -> { log.info("@Bean with both dependencies (projectName): " + projectName); log.info("@Bean with both dependencies (env): " + env.getProperty("configuration.projectName")); }; } @PostConstruct void afterPropertiesSet() throws Throwable { log.info("fieldValue: " + this.fieldValue); } } 

(1) Annotation @PropertySource ist eine Abkürzung ähnlich dem Property-Placeholder, mit der eine PropertySource aus einer Datei mit der Erweiterung .properties eingerichtet wird.

(2) PropertySourcesPlaceholderConfigurer muss als statische Bean registriert werden, da es sich um eine Implementierung des BeanFactoryPostProcessor handelt und zu einem frühen Zeitpunkt im Initialisierungslebenszyklus der Spring Bean aufgerufen werden muss. Bei Verwendung von Bean-Komponenten in der Spring XML-Konfiguration ist diese Nuance nicht sichtbar.

(3) Sie können die Felder mit der Wertanmerkung dekorieren (aber tun Sie dies nicht, sonst besteht der Code den Test nicht!) ...

(4) ... oder die Annotation Value kann die Konstruktorparameter dekorieren ...

(5) ... oder Installationsmethoden verwenden ...

(6) ... oder binden Sie ein Spring Environment-Objekt ein und führen Sie die Schlüsselauflösung manuell durch.

(7) Parameter mit der Annotation Value können auch im Bean- Methodenargumentanbieter in der Spring Java-Konfiguration verwendet werden.

In diesem Beispiel werden die Werte aus der Datei simple.properties geladen und haben dann den Wert configuration.projectName, der auf verschiedene Arten bereitgestellt wird.

Profile

Unter anderem führt die Umgebungsabstraktion Profile ein . Auf diese Weise können Sie Beschriftungen (Profile) zuweisen, um Bean-Komponenten zu gruppieren. Profile sollten verwendet werden, um Bean-Komponenten und Bean-Diagramme zu beschreiben, die von Umgebung zu Umgebung variieren. Es können mehrere Profile gleichzeitig aktiviert werden. Bohnen, denen keine Profile zugewiesen sind, werden immer aktiviert. Beans mit einem Standardprofil werden nur aktiviert, wenn sie keine anderen aktiven Profile haben. Das Profilattribut kann in der Definition der Bean-Komponente in XML oder in Tag-Klassen, Konfigurationsklassen, einzelnen Bean-Komponenten oder in den Methoden des Bean- Anbieters unter Verwendung von Profile angegeben werden .

Mit Profilen können Sie Sätze von Bean-Komponenten beschreiben, die in einer Umgebung etwas anders als in einer anderen erstellt werden müssen. In einem lokalen Entwicklungsentwicklungsprofil können Sie beispielsweise die integrierte H2-Datenquelle javax.sql.DataSource verwenden und dann, wenn das Produktprofil aktiv ist, zur Datenquelle javax.sql.DataSource wechseln, die mit der JNDI-Suche oder erhalten wurde durch Lesen von Eigenschaften aus einer Umgebungsvariablen in Cloud Foundry . In beiden Fällen funktioniert Ihr Code: Sie erhalten javax.sql.DataSource, aber die Entscheidung, welche bestimmte Instanz verwendet werden soll, wird durch Aktivieren eines oder mehrerer Profile getroffen (Beispiel 3.5).

Beispiel 3.5 Demonstration, dass @ Configuration-Klassen verschiedene Konfigurationsdateien laden und basierend auf verschiedene Beans bereitstellen können
aktives Profil

 package profiles; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.*; import org.springframework.context.support.PropertySourcesPlaceholderConfigurer; import org.springframework.core.env.Environment; import org.springframework.util.StringUtils; @Configuration public class Application { private Log log = LogFactory.getLog(getClass()); @Bean static PropertySourcesPlaceholderConfigurer pspc() { return new PropertySourcesPlaceholderConfigurer(); } (1) @Configuration @Profile("prod") @PropertySource("some-prod.properties") public static class ProdConfiguration { @Bean InitializingBean init() { return () -> LogFactory.getLog(getClass()).info("prod InitializingBean"); } } @Configuration @Profile({ "default", "dev" }) (2) @PropertySource("some.properties") public static class DefaultConfiguration { @Bean InitializingBean init() { return () -> LogFactory.getLog(getClass()).info("default InitializingBean"); } } (3) @Bean InitializingBean which(Environment e, @Value("${configuration.projectName}") String projectName) { return () -> { log.info("activeProfiles: '" + StringUtils.arrayToCommaDelimitedString(e.getActiveProfiles()) + "'"); log.info("configuration.projectName: " + projectName); }; } public static void main(String[] args) { AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(); ac.getEnvironment().setActiveProfiles("dev"); (4) ac.register(Application.class); ac.refresh(); } } 

(1) Diese Konfigurationsklasse und alle darin enthaltenen Bean- Definitionen werden nur berechnet, wenn das Produktprofil aktiv ist.

(2) Diese Konfigurationsklasse und alle darin enthaltenen Bean- Definitionen werden nur berechnet, wenn das Entwicklungsprofil aktiv ist oder kein Profil aktiv ist, einschließlich Entwickler.

(3) Diese InitializingBean-Komponente zeichnet einfach das aktuell aktive Profil auf und gibt den Wert ein, der schließlich in die Eigenschaftendatei eingegeben wurde.

(4) Das programmgesteuerte Aktivieren eines Profils (oder von Profilen) ist recht einfach.

Spring reagiert auf verschiedene andere Profilaktivierungsmethoden mit dem Token spring_profiles_active oder spring.profiles.active. Ein Profil kann mithilfe einer Umgebungsvariablen (z. B. SPRING_PROFILES_ACTIVE), einer JVM-Eigenschaft (‑Dspring.profiles.active = ...), eines Servlet-Anwendungsinitialisierungsparameters oder programmgesteuert festgelegt werden.

Bootiful Konfiguration

Spring Boot verbessert die Situation erheblich. Die Umgebung lädt zunächst automatisch Eigenschaften aus einer Hierarchie vordefinierter Speicherorte. Befehlszeilenargumente überschreiben von JNDI abgeleitete Eigenschaftswerte, die von System.getProperties () usw. erhaltene Eigenschaften überschreiben.

- Befehlszeilenargumente.
- JNDI-Attribute aus Java: comp / env.
- Eigenschaften von System.getProperties ().
- Umgebungsvariablen des Betriebssystems.
- Externe Eigenschaftendateien im Dateisystem: (config /)? Application. (Yml.properties).
- Interne Eigenschaftendateien im Archiv (config /)? Application. (Yml.properties).
- Annotation @PropertySource in Konfigurationsklassen.
- Quelleneigenschaften von SpringApplication.getDefaultProperties ().

Wenn das Profil aktiv ist, werden Daten aus Konfigurationsdateien basierend auf dem Profilnamen automatisch gelesen, z. B. aus einer Datei wie src / main / resources / application-foo.properties, wobei foo das aktuelle Profil ist.

Wenn die SnakeYAML- Bibliothek in den Klassenpfaden erwähnt wird, werden auch YAML-Dateien automatisch geladen, wobei im Wesentlichen dieselbe Konvention angewendet wird .

Auf der YAML- Spezifikationsseite heißt es: „YAML ist ein lesbarer Standard für die Serialisierung von Daten für alle Programmiersprachen.“ YAML ist eine hierarchische Darstellung von Werten. In regulären Dateien mit der Erweiterung .properties wird die Hierarchie durch einen Punkt (".") Angezeigt. In YAML-Dateien werden eine neue Zeile und eine zusätzliche Einrückungsstufe verwendet. Es wäre schön, diese Dateien zu verwenden, um zu vermeiden, dass bei stark verzweigten Konfigurationsbäumen gemeinsame Wurzeln angegeben werden müssen.

Der Inhalt einer Datei mit der Erweiterung .yml ist in Beispiel 3.6 dargestellt.

Beispiel 3.6 Eigenschaftendatei Application.yml. Die Daten werden in hierarchischer Reihenfolge dargestellt.

 configuration: projectName : Spring Boot management: security: enabled: false 

Darüber hinaus macht es die Spring Boot-Umgebung in allgemeinen Fällen viel einfacher, das richtige Ergebnis zu erzielen. Die Argumente -D werden in Prozess- und Java-Umgebungsvariablen umgewandelt, die als Eigenschaften verfügbar sind. Sie führt sogar ihre Normalisierung durch, bei der die Umgebungsvariable $ CONFIGURATION_PROJECTNAME (PROJECT_NAME CONFIGURATION) oder das Argument -D in der Form –Dconfiguration.projectName (configuration.project_name) wie zuvor mit dem Schlüssel configuration.projectName (configuration.project_name) verfügbar gemacht werden Das Token spring_profiles_active ist verfügbar.

Konfigurationswerte sind Zeichenfolgen, und wenn sie ausreichen, können sie unlesbar werden, wenn versucht wird, sicherzustellen, dass solche Schlüssel selbst nicht zu magischen Zeichenfolgen im Code werden. Spring Boot führt den Komponententyp @ConfigurationProperties ein. Wenn Sie ein POJO - Plain Old Java Object - mit @ConfigurationProperties kommentieren und ein Präfix angeben, versucht Spring, alle Eigenschaften, die mit diesem Präfix beginnen, POJO-Eigenschaften zuzuordnen. Im folgenden Beispiel wird der Wert für configuration.projectName einer POJO-Instanz zugeordnet, die dann vom gesamten Code injiziert und dereferenziert werden kann, um typsichere Werte zu lesen. Infolgedessen haben Sie nur an einer Stelle eine Zuordnung vom Schlüssel (String) (Beispiel 3.7).

Beispiel 3.7. Automatisches Auflösen von Eigenschaften aus src / main / resources / application.yml
Paketstart;

 import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.stereotype.Component; (1) @EnableConfigurationProperties @SpringBootApplication public class Application { private final Log log = LogFactory.getLog(getClass()); public static void main(String[] args) { SpringApplication.run(Application.class); } @Autowired public Application(ConfigurationProjectProperties cp) { log.info("configurationProjectProperties.projectName = " + cp.getProjectName()); } } (2) @Component @ConfigurationProperties("configuration") class ConfigurationProjectProperties { private String projectName; (3) public String getProjectName() { return projectName; } public void setProjectName(String projectName) { this.projectName = projectName; } } 

(1) Die Annotation @EnableConfigurationProperties weist Spring an, Eigenschaften POJOs zuzuordnen, die mit @ConfigurationProperties annotiert sind.

(2) Die Annotation @ConfigurationProperties zeigt Spring, dass diese Bean als Stamm für alle Eigenschaften verwendet werden sollte, beginnend mit der Konfiguration. Gefolgt von Token, die den Eigenschaften des Objekts zugeordnet sind.

(3) Dem Feld projectName wird letztendlich der Wert zugewiesen, der dem Eigenschaftsschlüssel configuration.projectName zugewiesen ist.

Spring Boot verwendet aktiv den @ ConfigurationProperties-Mechanismus, um Benutzern die Möglichkeit zu geben, die elementaren Komponenten des Systems zu überschreiben. Möglicherweise stellen Sie fest, dass Sie mit den Eigenschaftsschlüsseln Änderungen vornehmen können, indem Sie beispielsweise der Spring Boot-Webanwendung die Abhängigkeit org.springframework.boot: Spring-Boot-Starter-Actuator hinzufügen und dann Seite 127.0.0.1 : 8080 / configprops aufrufen.

Die Aktorendpunkte werden in Kapitel 13 ausführlicher erläutert. Sie sind gesperrt und erfordern einen Standardbenutzernamen und ein Standardkennwort. Sicherheitsmaßnahmen können deaktiviert werden (jedoch nur, um diese Punkte zu betrachten), indem management.security.enabled = false in der Datei application.properties (oder in application.yml) angegeben wird.

Sie erhalten eine Liste der unterstützten Konfigurationseigenschaften basierend auf den Typen, die zur Laufzeit in den Klassenpfaden angezeigt werden. Wenn die Anzahl der Spring Boot-Typen zunimmt, werden zusätzliche Eigenschaften angezeigt. Dieser Endpunkt zeigt auch Eigenschaften an, die von Ihren POJOs mit der Annotation @ConfigurationProperties exportiert wurden.

Zentralisierte registrierte Konfiguration mit Spring Cloud Configuration Server

Bisher ist alles in Ordnung, aber die Dinge müssen noch erfolgreicher sein. Wir haben noch keine Fragen zu häufigen Anwendungsfällen beantwortet:

• Nach Änderungen an der Anwendungskonfiguration ist ein Neustart erforderlich.
• Keine Rückverfolgbarkeit: Wie können die in Betrieb genommenen Änderungen ermittelt und gegebenenfalls zurückgesetzt werden?
• Konfiguration ist dezentral; Es ist nicht sofort klar, wo Änderungen vorgenommen werden sollten, um den einen oder anderen Aspekt zu ändern.
• Keine Installationsunterstützung für das Codieren und Decodieren aus Sicherheitsgründen.

Spring Cloud-Konfigurationsserver

Das Problem der Zentralisierung der Konfiguration kann gelöst werden, indem die Konfiguration in einem Verzeichnis gespeichert und alle Anwendungen darauf verwiesen werden. Sie können die Versionskontrolle dieses Verzeichnisses auch mit Git oder Subversion installieren. Dann wird die für die Überprüfung und Registrierung erforderliche Unterstützung erhalten. Die letzten beiden Anforderungen werden jedoch immer noch nicht erfüllt, sodass etwas Anspruchsvolleres erforderlich ist. Wenden Sie sich an den Spring Cloud- Konfigurationsserver. Die Spring Cloud-Plattform bietet einen Konfigurationsserver und einen Client für diesen Server.

Der Spring Cloud Config-Server ist eine REST-API, mit der unsere Clients eine Verbindung herstellen, um ihre Konfiguration abzurufen. Der Server verwaltet auch das Versionskontrollkonfigurations-Repository. Er ist ein Vermittler zwischen unseren Kunden und dem Konfigurations-Repository und daher in einer günstigen Position, um Sicherheitstools zum Verbinden von Verbindungen von Clients zum Dienst und Verbindungen vom Dienst zum Konfigurations-Repository mit Versionskontrolle zu implementieren. Der Spring Cloud Config-Client bietet Clientanwendungen einen neuen Bereich, die Aktualisierung, mit der Sie Spring-Komponenten erneut konfigurieren können, ohne die Anwendung neu starten zu müssen.

Technologien wie der Spring Cloud Config-Server spielen eine wichtige Rolle, verursachen jedoch zusätzlichen Aufwand. Im Idealfall sollte diese Verantwortung auf die Plattform übertragen und automatisiert werden. Bei Verwendung von Cloud Foundry finden Sie den Config Server-Dienst im Dienstkatalog, dessen Aktionen auf der Verwendung des Spring Cloud Config-Servers basieren.

Betrachten Sie ein einfaches Beispiel. Konfigurieren Sie zunächst den Spring Cloud Config-Server. Auf einen solchen Dienst können mehrere Spring Boot-Anwendungen gleichzeitig zugreifen. Sie müssen dafür sorgen, dass es irgendwo und irgendwie funktioniert. Dann müssen nur noch alle unsere Dienste darüber informiert werden, wo sich der Konfigurationsdienst befindet. Es fungiert als eine Art Vermittler für Konfigurationsschlüssel und -werte, die vom Git-Speicher über das Netzwerk oder von der Festplatte gelesen werden. Fügen Sie der Assembly Ihrer Spring Boot-Anwendung die Zeichenfolge org.springframework.cloud: spring-cloud-config-server hinzu, um den Spring Cloud Config-Server aufzurufen (Beispiel 3.8).

Beispiel 3.8. Verwenden Sie die Annotation @EnableConfigServer, um einen Konfigurationsserver in die Assembly einzubetten

 package demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.config.server.EnableConfigServer; (1) @SpringBootApplication @EnableConfigServer public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } 

(1) Durch die Verwendung der Annotation @EnableConfigServer wird der Spring Cloud Config-Server installiert.

Beispiel 3.9 zeigt die Konfiguration für den Konfigurationsdienst.

Beispiel 3.9. Konfiguration des Konfigurationsservers Src / main / resources / application.yml

server.port = 8888
spring.cloud.config.server.git.uri = \
github.com/cloud-native-java/config-server-configuration-repository (1)

(1) Ein Hinweis auf ein funktionierendes Git-Repository, das lokaler Natur ist oder über das Netzwerk zugänglich ist (z. B. auf GitHub (https://github.com/)) und vom Spring Cloud Config-Server verwendet wird.

Hier wird der Spring Cloud-Konfigurationsdienst angewiesen, im Git-Repository auf GitHub nach Konfigurationsdateien für einzelne Clients zu suchen. Wir haben auf dieses Repository verwiesen, aber ein Link zu einem gültigen Git-URI würde ausreichen. Natürlich muss er sich nicht einmal auf das Git-System anwenden, Sie können Subversion oder sogar nicht verwaltete Verzeichnisse verwenden (obwohl wir dringend davon abraten). In diesem Fall ist der Speicher-URI fest codiert, aber nichts hindert ihn daran, vom Argument -D, vom Argument oder von einer Umgebungsvariablen zu stammen.

»Weitere Informationen zum Buch finden Sie auf der Website des Herausgebers
» Inhalt
» Auszug

20% Rabatt auf den Gutschein für Java Fermenter - Java