{"id":145,"date":"2024-01-05T22:36:00","date_gmt":"2024-01-05T21:36:00","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=145"},"modified":"2024-01-09T21:21:04","modified_gmt":"2024-01-09T20:21:04","slug":"145","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=145","title":{"rendered":"Konfigurationsverwaltung in Spring Boot mit @ConfigurationProperties"},"content":{"rendered":"\n

Spring Boot ist ein Framework, das die Entwicklung von Java-Anwendungen erleichtert. Eine wichtige Komponente in jeder Anwendung ist die Verwaltung von Konfigurationsdaten. Diese Daten k\u00f6nnen Parameter wie Datenbankverbindungen, API-Endpunkte, Schwellenwerte und viele andere Einstellungen sein. In diesem Artikel werden wir untersuchen, wie Sie mit der @ConfigurationProperties<\/code>-Annotation Konfigurationsdaten in Ihre Spring Boot-Anwendung einlesen und darauf zugreifen k\u00f6nnen.<\/p>\n\n\n\n

Die @ConfigurationProperties-Annotation<\/h2>\n\n\n\n

Die @ConfigurationProperties<\/code>-Annotation ist ein Schl\u00fcsselkonzept in Spring Boot, um Konfigurationsdaten in einer strukturierten Weise zu verwalten. Sie erm\u00f6glicht es Ihnen, Konfigurationsdaten aus verschiedenen Quellen wie application.properties<\/code>, application.yml<\/code>, Umgebungsvariablen und benutzerdefinierten Quellen zu laden und diese Daten in POJOs (Plain Old Java Objects) zu binden. Dies erleichtert die Verwendung und Aktualisierung von Konfigurationsdaten in Ihrer Anwendung.<\/p>\n\n\n\n

Schritt-f\u00fcr-Schritt-Anleitung<\/h2>\n\n\n\n

Lassen Sie uns nun Schritt f\u00fcr Schritt durchgehen, wie Sie @ConfigurationProperties<\/code> in Ihrer Spring Boot-Anwendung verwenden k\u00f6nnen.<\/p>\n\n\n\n

Schritt 1: Abh\u00e4ngigkeiten hinzuf\u00fcgen<\/h3>\n\n\n\n

Zuerst m\u00fcssen Sie sicherstellen, dass Sie die richtigen Abh\u00e4ngigkeiten in Ihrer build.gradle<\/code> oder pom.xml<\/code> Datei haben, um die Verwendung von Spring Boot und @ConfigurationProperties<\/code> zu erm\u00f6glichen. In den meisten F\u00e4llen sind diese Abh\u00e4ngigkeiten bereits in einem Spring Boot-Projekt vorhanden.<\/p>\n\n\n\n

Schritt 2: Konfigurationsklasse erstellen<\/h3>\n\n\n\n

Erstellen Sie eine Java-Klasse, die als Konfigurationsklasse dient und die @Configuration<\/code>-Annotation enth\u00e4lt (dadurch wird sie von Spring direkt als Bean instanziert – diese Annotation ist, auch wenn der Name es suggerieren mag, nicht zwingend n\u00f6tig, um Konfigurationsdaten \u00fcber die @ConfigurationProperties<\/code>-Annotation einzulesen; das geht auch mit jeder anderen Spring Bean Klasse). In dieser Klasse werden die Konfigurationsdaten und deren Struktur definiert.<\/p>\n\n\n

import<\/span> org.springframework.boot.context.properties.ConfigurationProperties;\nimport<\/span> org.springframework.context.annotation.Configuration;\n\n@Configuration\n@ConfigurationProperties(prefix = \"meineanwendung\"<\/span>)\npublic class<\/span> AnwendungsEinstellungen<\/span> <\/span>{\n    private String<\/span> name;\n    private int port;\n    private List<String<\/span>> serverList;\n    private Map<\/span><String<\/span>, String<\/span>> zusatzInformationen;\n\n    \/\/ Getter und Setter f\u00fcr die oben definierten Felder<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel erstellen wir eine Klasse namens AnwendungsEinstellungen<\/code>, die Konfigurationsdaten f\u00fcr unsere Anwendung enth\u00e4lt. Die @ConfigurationProperties<\/code>-Annotation wird mit dem prefix<\/code>-Parameter verwendet, um die Konfigurationsdaten zu gruppieren. Hier verwenden wir das Prefix „meineanwendung“, und daher werden alle Konfigurationsdaten, die mit diesem Prefix beginnen, in diese Klasse gebunden.<\/p>\n\n\n\n
Schritt 3: Konfigurationsdatei erstellen<\/h3>\n\n\n\n
Erstellen Sie eine Konfigurationsdatei (normalerweise application.properties<\/code> oder application.yml<\/code>), in der Sie die Konfigurationsdaten definieren. Beachten Sie, dass das Prefix im Namen der Eigenschaften in der Datei entsprechen muss.<\/p>\n\n\n\n
application.properties:<\/h4>\n\n\n
meineanwendung.name=Meine Spring Boot Anwendung\nmeineanwendung.port=8080\nmeineanwendung.serverList=Server1,Server2,Server3\nmeineanwendung.zusatzInformationen.key1=Wert 1\nmeineanwendung.zusatzInformationen.key2=Wert 2<\/code><\/span><\/pre>\n\n\n
application.yml:<\/h4>\n\n\n
meineanwendung:\n  name: Meine Spring Boot Anwendung\n  port: 8080\n  serverList:\n    - Server1\n    - Server2\n    - Server3\n  zusatzInformationen:\n    key1: Wert 1\n    key2: Wert 2<\/code><\/span><\/pre>\n\n\n
In der Konfigurationsdatei sind die Eigenschaften genau wie in der AnwendungsEinstellungen<\/code>-Klasse strukturiert und mit dem entsprechenden Prefix versehen.<\/p>\n\n\n\n
Schritt 4: Anwendungsklasse konfigurieren<\/h3>\n\n\n\n
In Ihrer Hauptanwendungsklasse m\u00fcssen Sie die Konfigurationsklasse registrieren, indem Sie die @EnableConfigurationProperties<\/code>-Annotation verwenden. Dies erm\u00f6glicht es Spring Boot, die Konfigurationsdaten aus der Datei in die AnwendungsEinstellungen<\/code>-Klasse zu binden.<\/p>\n\n\n
import<\/span> org.springframework.boot.SpringApplication;\nimport<\/span> org.springframework.boot.autoconfigure.SpringBootApplication;\nimport<\/span> org.springframework.boot.context.properties.EnableConfigurationProperties;\n\n@SpringBootApplication\n@EnableConfigurationProperties(AnwendungsEinstellungen.class)\npublic class<\/span> MeinAnwendungsStarter<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        SpringApplication.run(MeinAnwendungsStarter.class, args);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Schritt 5: Konfigurationsdaten verwenden<\/h3>\n\n\n\n
Nun k\u00f6nnen Sie die Konfigurationsdaten in Ihren Spring Beans verwenden, indem Sie einfach eine Instanz der AnwendungsEinstellungen<\/code>-Klasse injizieren. Spring Boot wird automatisch die Daten aus der Konfigurationsdatei laden und in diese Instanz binden.<\/p>\n\n\n
import org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.stereotype.Component;\n\n@Component\npublic<\/span> class<\/span> MeinService<\/span> <\/span>{\n    private<\/span> final<\/span> AnwendungsEinstellungen einstellungen;\n\n    @Autowired\n    public<\/span> MeinService(AnwendungsEinstellungen einstellungen) {\n        this.einstellungen = einstellungen;\n    }\n\n    public<\/span> void zeigeKonfiguration() {\n        System.out.println(\"Anwendungsname: \"<\/span> + einstellungen.getName());\n        System.out.println(\"Port: \"<\/span> + einstellungen.getPort());\n        System.out.println(\"Serverliste: \"<\/span> + einstellungen.getServerList());\n        System.out.println(\"Zusatzinformationen: \"<\/span> + einstellungen.getZusatzInformationen());\n    }\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel haben wir eine Serviceklasse erstellt und die AnwendungsEinstellungen<\/code>-Instanz \u00fcber den Konstruktor injiziert. Sie k\u00f6nnen nun problemlos auf alle Konfigurationsdaten zugreifen.<\/p>\n\n\n\n
Schritt 6: Anwendung starten<\/h3>\n\n\n\n
Jetzt k\u00f6nnen Sie Ihre Spring Boot-Anwendung starten und auf die Konfigurationsdaten zugreifen, die in der AnwendungsEinstellungen<\/code>-Klasse definiert sind. F\u00fchren Sie einfach die zeigeKonfiguration()<\/code>-Methode Ihres Dienstes aus.<\/p>\n\n\n
@SpringBootApplication\n@EnableConfigurationProperties(AnwendungsEinstellungen.class)\npublic class<\/span> MeinAnwendungsStarter<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        ApplicationContext context = SpringApplication.run(Me\n\ninAnwendungsStarter.class, args);\n        MeinService service = context.getBean(MeinService.class);\n        service.zeigeKonfiguration();\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Komplexe Objektbaumstrukturen<\/h2>\n\n\n\n
In vielen F\u00e4llen werden Sie Konfigurationsdaten haben, die komplexere Strukturen erfordern. Dies k\u00f6nnen verschachtelte Objekte, Listen oder Maps sein. Spring Boot unterst\u00fctzt diese Szenarien problemlos.<\/p>\n\n\n\n
Verschachtelte Objekte<\/h3>\n\n\n\n
Sie k\u00f6nnen verschachtelte Objekte in Ihrer AnwendungsEinstellungen<\/code>-Klasse erstellen, um komplexere Konfigurationsdaten zu verwalten. Zum Beispiel:<\/p>\n\n\n
public<\/span> class<\/span> AnwendungsEinstellungen<\/span> <\/span>{\n    private<\/span> Server server;\n    \/\/ ...<\/span>\n\n    \/\/ Getter und Setter<\/span>\n}\n\npublic<\/span> class<\/span> Server<\/span> <\/span>{\n    private<\/span> String name;\n    private<\/span> int port;\n    \/\/ ...<\/span>\n\n    \/\/ Getter und Setter<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Die entsprechenden Konfigurationsdaten in Ihrer application.properties<\/code> oder application.yml<\/code> Datei w\u00fcrden so aussehen:<\/p>\n\n\n
meineanwendung.server.name=Mein Server\nmeineanwendung.server.port=8080<\/code><\/span><\/pre>\n\n\n
Listen<\/h3>\n\n\n\n
Wenn Sie eine Liste von Werten haben, k\u00f6nnen Sie sie einfach als Feld in Ihrer Konfigurationsklasse definieren. Zum Beispiel:<\/p>\n\n\n
public<\/span> class<\/span> AnwendungsEinstellungen<\/span> <\/span>{\n    private<\/span> List<\/span><String> serverList;\n    \/\/ ...<\/span>\n\n    \/\/ Getter und Setter<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Die entsprechende Konfigurationsdatei w\u00fcrde so aussehen:<\/p>\n\n\n
meineanwendung.serverList=Server1,Server2,Server3<\/code><\/span><\/pre>\n\n\n
Maps<\/h3>\n\n\n\n
Wenn Sie eine Map von Schl\u00fcssel-Wert-Paaren ben\u00f6tigen, k\u00f6nnen Sie dies ebenfalls in Ihrer Konfigurationsklasse definieren. Zum Beispiel:<\/p>\n\n\n
public class<\/span> AnwendungsEinstellungen<\/span> <\/span>{\n    private Map<\/span><String<\/span>, String<\/span>> zusatzInformationen;\n    \/\/ ...<\/span>\n\n    \/\/ Getter und Setter<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Die entsprechende Konfigurationsdatei w\u00fcrde so aussehen:<\/p>\n\n\n
meineanwendung.zusatzInformationen.key1=Wert 1\nmeineanwendung.zusatzInformationen.key2=Wert 2<\/code><\/span><\/pre>\n\n\n
Fazit<\/h2>\n\n\n\n
Die @ConfigurationProperties<\/code>-Annotation ist ein leistungsf\u00e4higes Werkzeug in Spring Boot, um Konfigurationsdaten in Ihrer Anwendung zu verwalten. Mit dieser Annotation k\u00f6nnen Sie die Struktur Ihrer Konfigurationsdaten definieren, sie aus verschiedenen Quellen laden und nahtlos in Ihre Anwendung integrieren. Dies erm\u00f6glicht eine saubere und wartbare Verwaltung von Konfigurationsdaten, selbst bei komplexen Objektbaumstrukturen, Listen und Maps.<\/p>\n\n\n\n
In diesem Artikel haben wir die grundlegenden Schritte zur Verwendung von @ConfigurationProperties<\/code> in Ihrer Spring Boot-Anwendung erl\u00e4utert. Wir haben auch gezeigt, wie Sie mit komplexeren Datenstrukturen umgehen k\u00f6nnen. Mit diesem Wissen k\u00f6nnen Sie Ihre Anwendungen flexibler gestalten und Konfigurationsdaten effizienter verwalten.<\/p>\n\n\n\n
Die Verwendung von @ConfigurationProperties<\/code> ist nur eine der vielen M\u00f6glichkeiten zur Verwaltung von Konfigurationsdaten in Spring Boot. Je nach den Anforderungen Ihrer Anwendung k\u00f6nnen Sie auch andere Ans\u00e4tze wie Umgebungsvariablen, die Spring Cloud Config Server oder externe Konfigurationsquellen in Betracht ziehen. Die Wahl des richtigen Ansatzes h\u00e4ngt von den spezifischen Anforderungen Ihres Projekts ab.<\/p>\n","protected":false},"excerpt":{"rendered":"
Spring Boot ist ein Framework, das die Entwicklung von Java-Anwendungen erleichtert. Eine wichtige Komponente in jeder Anwendung ist die Verwaltung von Konfigurationsdaten. Diese Daten k\u00f6nnen Parameter wie Datenbankverbindungen, API-Endpunkte, Schwellenwerte und viele andere Einstellungen sein. In diesem Artikel werden wir untersuchen, wie Sie mit der @ConfigurationProperties-Annotation Konfigurationsdaten in Ihre Spring Boot-Anwendung einlesen und darauf zugreifen […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5],"tags":[],"class_list":["post-145","post","type-post","status-publish","format-standard","hentry","category-spring"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/145","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=145"}],"version-history":[{"count":2,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/145\/revisions"}],"predecessor-version":[{"id":147,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/145\/revisions\/147"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=145"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=145"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=145"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}