# Spring-Boot-Tutorial: Java-Apps mit Spring Boot erstellen Seit ihrer Veröffentlichung im Jahr 1995 zählt Java zu den populärsten und meistgenutzten Programmiersprachen. Insbesondere, wenn es um die **Realisierung komplexer Business-Applikationen** (online oder offline) geht, spielt die objektorientierte Sprache ihre Stärken aus. In Kombination mit der Java-Laufzeitumgebung (JRE) zeichnen sich diese Anwendungen vor allem durch ihre Plattformunabhängigkeit aus, die sie für ein besonders breites Publikum verfügbar macht. Um die **Arbeit mit Java zu vereinfachen**, wurden im Laufe der vergangenen Jahrzehnte diverse Frameworks entwickelt, die dem Nutzer ein **einsatzfertiges Basisgerüst** für das zu entwickelnde Java-Programm zur Verfügung stellen. Eines der bekanntesten ist das bereits 2003 veröffentlichte Open-Source-Framework [Spring](https://spring.io/ "Offizielle Homepage des Java-Frameworks Spring"), das die Komplexität der standardmäßigen Java-Spezifikation („J2EE“ bzw. „Java Plattform“) sowie des Komponentenmodells Enterprise JavaBeans („EJB“) bedeutend reduziert. Spätestens seit dem Release der Ergänzung Spring Boot, die die Konfiguration neuer Spring-Projekte zusätzlich vereinfacht, erweist sich das Gerüst als exzellente und nutzerfreundliche Wahl für alle, die bei der Entwicklung einer neuen Java-Applikation nicht komplett bei null anfangen wollen. In diesem Spring-Boot-Tutorial erfahren Sie, welche Voraussetzungen es für die Nutzung zu erfüllen gilt und wie Sie die ersten Schritte mit dem modular aufgebauten Framework und dem Aufsatz Spring Boot bewältigen. ## Was ist Spring Boot? Spring Boot ist eine „Konvention vor Konfiguration“-Lösung für das Java-Framework Spring, die 2012 veröffentlicht wurde und die **Komplexität der Konfiguration neuer Spring-Projekte reduziert**. Zu diesem Zweck legt Spring Boot eine Grundkonfiguration inklusive Richtlinien für die Nutzung des Frameworks sowie aller relevanten Drittanbieter-Bibliotheken fest und gibt damit den Weg vor, um den Einstieg in neue Projekte so mühelos wie möglich zu gestalten. Auf diese Weise lässt sich die Kreation eigenständiger, produktionsreifer Applikationen auf Basis von Spring erheblich vereinfachen, weshalb der **Großteil neuer Spring-Anwendungen** konsequenterweise auch **auf Spring Boot aufsetzt**. Die **Merkmale von Spring Boot** lassen sich wie folgt zusammenfassen: - direktes **Einbetten** von Webserver-/Container-Anwendungen wie Apache Tomcat oder Jetty möglich, wodurch kein Einsatz von WAR-Dateien (**W**eb **A**pplication **Ar**chive) erforderlich ist - **vereinfachte** Maven-Konfiguration dank „Starter“-POMs (**P**roject **O**bject **M**odels) - automatische **Spring-Konfiguration**, wann immer dies möglich ist - **Bereitstellung** nichtfunktionaler Features wie Metriken oder ausgelagerter Konfigurationen Mit Spring Boot hat die Entwicklerfirma Pivotal Software dem bereits 2005 erschienenen Framework einen modernen, zukunftsgerichteten Ansatz verliehen. Die Erweiterung profitiert dabei von der **über Jahre gereiften Basistechnologie des Spring-Frameworks**, die auch maßgeblich in Spring Boot eingeflossen ist. Detaillierte Informationen zu dem quelloffenen Framework (Apache License 2.0) selbst erhalten Sie in unserem ausführlichen [Artikel über das Spring Framework](https://www.ionos.at/digitalguide/websites/web-entwicklung/spring-framework-das-steckt-in-dem-java-grundgeruest/). ## Spring-Boot-Tutorial: Anforderungen, Installation und erste Schritte Seit der Erweiterung von Spring durch Spring Boot gilt die Software von Pivotal Software als eine der besten Lösungen für die Entwicklung von [Microservices](https://www.ionos.at/digitalguide/websites/web-entwicklung/microservice-architecture-so-funktionieren-microservices/ "Microservice-Architecture | So funktionieren Microservices") in Java. Dank der **rund 20 Module** des Basis-Frameworks, die sich nach Belieben zusammenstellen lassen, eignet sich Spring Boot jedoch auch für diverse andere Szenarien, wobei es sich weder konkret als [Framework für Webapplikationen](https://www.ionos.at/digitalguide/websites/web-entwicklung/webframeworks-ein-ueberblick/ "Webframeworks – ein Überblick") noch als klassische Lösung für Desktop-Apps einordnen lässt. Bevor wir im folgenden Spring-Boot-Tutorial (deutsch) näher auf die Konfiguration und Kreation eines neuen Projekts sowie die initiale Spring-Boot-Struktur eingehen, befassen wir uns zunächst mit den technischen Anforderungen und der Einrichtung der erforderlichen Projektkomponenten. ### Welche Systemvoraussetzungen stellt Spring Boot? Bei Spring Boot dreht sich alles um Java, weshalb die Java-Laufzeitumgebung (Java Platform) die zentrale Software-Komponente ist, um das Framework zum Laufen zu bringen. Da Sie die Anwendung nicht nur ausführen, sondern auch für die Entwicklung mit Java nutzen, benötigen Sie mindestens Version 8 (bzw. 1.8) des sogenannten **Java Development Kit** (JDK). Dieses enthält zusätzlich zur Laufzeitumgebung nützliche Tools, um Java-Applikationen zu programmieren und zu testen. Es ist sowohl für Linux als auch für Windows und macOS verfügbar ist, **hinsichtlich des Betriebssystems** haben Sie also **freie Auswahl**. Selbstverständlich setzt die Erweiterung auch voraus, dass die **aktuelle Version des Spring-Frameworks** selbst auf dem System installiert ist. Als Build-Tool kommen entweder **Maven** (ab 3.3) oder **Gradle** (ab 4.4) in Frage. Wollen Sie von der Möglichkeit Gebrauch machen, einen Webserver einzubinden, der Ihre Java-Applikation auf Servlet-Basis ausführt, haben Sie die Wahl zwischen den drei Lösungen **Apache Tomcat** (ab 9.0), **Jetty** (ab 9.4) und **Undertow** (ab 2.0). ### So erstellen Sie Ihr erstes Spring-Boot-Projekt Spring Boot verwenden Sie ebenso wie jede Standard-Java-Bibliothek, indem Sie die entsprechenden **[JAR](https://www.ionos.at/digitalguide/server/knowhow/jar-format/ ".jar-Format")-** (Java Archive) bzw. **WAR-Dateien** (Web Application Archive) **in den Klassenpfad (Classpath) einbinden**. Diesen Pfad im Dateisystem nutzt Java, um nach ausführbaren Dateien zu suchen. Die Archivdateien für Spring Boot können Sie dabei auf zwei verschiedenen Wegen erstellen: - Sie installieren und nutzen **Maven** oder **Gradle**, um das Projektgerüst inklusive der erforderlichen Abhängigkeiten gänzlich auf eigene Faust zu erstellen. - Sie greifen auf den **Webservice Spring Initializr** zurück, stellen mit diesem Ihr Spring-Boot-Setup zusammen und laden es anschließend als fertige Projetvorlage herunter. Die Besonderheit letzterer Lösung besteht darin, dass Sie die JAR-Dateien über eine **nutzerfreundliche Weboberfläche** erstellen können, die den Prozess wesentlich vereinfacht. Da der Initializr ebenfalls auf Maven oder Gradle zurückgreift, um die Dateien zu generieren, unterscheidet sich das Ergebnis nämlich nicht von dem des manuellen Wegs. Im Rahmen dieses Java- bzw. Spring-Boot-Tutorials haben wir uns daher für den Webassistenten entschieden, der sich über die Adresse [start.spring.io](https://start.spring.io/ "Spring Initializr: Der Webservice für neue Spring-Boot-Projekte") aufrufen lässt. Hinweis Wenn Sie sich für die Nutzung von Spring Initializr entscheiden, müssen Java und Maven bzw. Gradle ebenso installiert sein, damit Sie an Ihrer Spring-Boot-Applikation arbeiten können. Haben Sie Spring Initializr geöffnet, können Sie der Reihe nach die gewünschten Eigenschaften Ihrer ersten Spring-Boot-Anwendung definieren: Zunächst legen Sie das Build-System fest, indem Sie „**Maven Project**“ oder „**Gradle Project**“ auswählen. Die zweite Zeile gibt Ihnen die Möglichkeit, sich für das klassische Java oder alternativ für eine andere Sprache der Java-Familie wie [Kotlin](https://www.ionos.at/digitalguide/websites/web-entwicklung/kotlin-tutorial/ "Kotlin-Tutorial") oder [Groovy](https://groovy-lang.org/ "Website von Apache Groovy") zu entscheiden. Ferner definieren Sie die zugrundeliegende Spring-Boot-Version, die Metadaten des Projekts (inklusive der Java-Version) sowie alle relevanten Abhängigkeiten (Datenbanken, Sicherheits-Features, Web-Schnittstellen, Cloud-Services etc.). Per Klick auf „**Generate Project**“ erzeugen Sie schließlich die Projektdateien. [![Bild: Spring Initializr: Erstellen eines Maven-basierten Spring-Boot-Projekts](https://www.ionos.at/digitalguide/fileadmin/_processed_/3/f/csm_spring-initializr_01de5d1bae.webp "Spring Initializr: Erstellen eines Maven-basierten Spring-Boot-Projekts")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2019/spring-initializr.jpg) Spring Initializr: Erstellen eines Maven-basierten Spring-Boot-Projekts Tipp Wollen Sie Ihr Spring-Boot-Projekt auf eigene Faust mit Maven und Gradle anlegen, können Sie sich an den [Installationsanleitungen](https://docs.spring.io/spring-boot/docs/current/reference/html/getting-started-installing-spring-boot.html "Spring-Boot-Tutorial (deutsch) – Installationsanweisungen für Java-Entwickler") in den offiziellen Online-Manuals orientieren. ### Erstelltes Spring-Boot-Projekt ausführen Spring Initializr bietet Ihnen die erzeugten Projektdateien zum Download an, wobei diese sich zunächst in einem ZIP-Archiv befinden, das Sie nach dem Herunterladen entpacken müssen. Im entpackten Ordner finden Sie u. a. die jeweilige Konfigurationsdatei: Haben Sie **Gradle** für das Build-Management ausgewählt, handelt es sich dabei um die Datei ***build.gradle***; bei **Maven-Projekten** sollten Sie dort die Datei ***pom.xml*** vorfinden. In letzterem Fall, der auch auf unser Vorgehen in diesem Spring-Boot-Tutorial zutrifft, sieht der Inhalt der Konfigurationsdatei in etwa wie folgt aus: [![Bild: Ausschnitt aus der generierten Maven-Konfigurationsdatei pom.xml](https://www.ionos.at/digitalguide/fileadmin/_processed_/6/9/csm_maven-konfigurationsdatei-pom-xml_a5a4619ad1.webp "Ausschnitt aus der generierten Maven-Konfigurationsdatei pom.xml")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2019/maven-konfigurationsdatei-pom-xml.jpg) Ausschnitt aus der generierten Maven-Konfigurationsdatei pom.xml Mithilfe der jeweiligen Build-Software kreieren Sie aus den vorliegenden Archivdateien eine **ausführbare Spring-Boot-Applikation**. Hierfür öffnen Sie das Terminal bzw. die Eingabeaufforderung und führen im Zielordner (also im Ordner Ihrer Spring-Boot-Dateien) den folgenden Befehl aus, wenn Sie **Maven** verwenden: ```none mvn clean install ``` [![Bild: Windows-Eingabeaufforderung: Generieren der JAR-Datei mit Maven](https://www.ionos.at/digitalguide/fileadmin/_processed_/4/4/csm_windows-eingabeaufforderung-jar-datei-maven_b30ff97f49.webp "Windows-Eingabeaufforderung: Generieren der JAR-Datei mit Maven")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2019/windows-eingabeaufforderung-jar-datei-maven.jpg) Windows-Eingabeaufforderung: Generieren der JAR-Datei mit Maven Für **Gradle-Projekte lautet der Befehl** indes folgendermaßen: ```none gradle clean build ``` In beiden Fällen erhalten Sie nach erfolgreicher Verarbeitung des Kommandos die Meldung „**BUILD SUCCESS**“, sobald die Archivdateien erfolgreich erstellt wurden. Die ausführbare Datei wird dabei im Ordner „**target**“ (Maven) bzw. unter „**build/libs**“ (Gradle) abgelegt. In unserem Fall lautet der Name dieser JAR-Datei „**demo-0.0.1-SNAPSHOT.jar**“: [![Bild: Generierte JAR-Datei im Maven-Ordner „target“ unter Windows 10](https://www.ionos.at/digitalguide/fileadmin/_processed_/e/5/csm_generierte-jar-datei-maven_cbc16d78d8.webp "Generierte JAR-Datei im Maven-Ordner „target“ unter Windows 10")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2019/generierte-jar-datei-maven.png) Generierte JAR-Datei im Maven-Ordner „target“ unter Windows 10 Ausführen lässt sie sich mithilfe von Java, indem Sie folgenden Befehl eintippen: ```none java -jar demo-0.0.1-SNAPSHOT.jar ``` [![Bild: Initialisierung der Spring-Boot-Anwendung](https://www.ionos.at/digitalguide/fileadmin/_processed_/a/e/csm_initialisierung-spring-boot-anwendung_bdbb46ebdc.webp "Initialisierung der Spring-Boot-Anwendung")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2019/initialisierung-spring-boot-anwendung.jpg) Initialisierung der Spring-Boot-Anwendung Den im Code-Beispiel zur Verdeutlichung kursiv gesetzten **Namen der JAR-Datei** gilt es dabei entsprechend **zu ersetzen**, falls sich dieser von dem hier genannten unterscheidet. Anhand des anschließend in der Kommandozeile angezeigten Outputs können Sie nun sehen, ob die Spring-Boot-Applikation erfolgreich gestartet werden konnte. Haben Sie einen der erwähnten Webserver wie Tomcat eingebunden, wird dieser ebenfalls gestartet. Sie können ihn mit dem Browser Ihrer Wahl ansprechen, indem Sie folgende Adresse abrufen: ```none http://localhost:8080 ``` ### Spring Boot mit Datenbank und Datenquelle verbinden Spring Boot bietet eine erstklassige Unterstützung bei der Kreation und Einbindung von Datenquellen in beliebige SQL- oder [NoSQL-Datenbanken](https://www.ionos.at/digitalguide/hosting/hosting-technik/nosql/ "NoSQL"). So müssen Sie hierfür keinen zusätzlichen Code schreiben, um eine neue Datenquelle anzulegen, sondern lediglich die erforderlichen Abhängigkeiten und Konfigurationsdetails hinzufügen. Möglich macht dies die einheitliche Datenbank-Schnittstelle **JDBC** (**J**ava **Datab**ase **C**onnectivity), für die es zunächst einen **Starter-Eintrag** in der Konfigurationsdatei zu erstellen gilt, falls Sie die Abhängigkeit nicht bereits bei der Kreation des Projekts mit Spring Initializr hinzugefügt haben (gleiches gilt für das Hinzufügen weiterer genannter Abhängigkeiten). **Maven-Nutzer** ergänzen hierfür in der *pom.xml* folgende Zeilen: ```none org.springframework.boot spring-boot-starter-jdbc ``` **Gradle-User** erledigen diesen Schritt durch das Einfügen des folgenden Eintrags in die *build.gradle*-Datei: ```none compile('org.springframework.boot:spring-boot-starter-jdbc') ``` Hinweis Sie können die jeweilige Konfigurationsdatei mit jedem handelsüblichen [Code-Editor](https://www.ionos.at/digitalguide/websites/web-entwicklung/code-editoren/) öffnen. Wichtig ist, dass die Datei im Anschluss an die Veränderungen auch wieder im XML- bzw. Gradle-Format gespeichert wird. Im zweiten Schritt erweitern Sie die jeweilige Build-Konfigurationsdatei um die Abhängigkeit für das gewünschte Datenbank-Management-System. In diesem Spring-Boot-Tutorial **verbinden** wir unsere Applikation **mit einer MySQL-Datenbank**, die wir für unsere Applikation nutzen wollen und zuvor bereits installiert haben. Die *pom.xml* von **Maven-Projekte** benötigt hierfür folgenden neuen Eintrag: ```none mysql mysql-connector-java ``` In der **Gradle-Konfiguration** muss folgende Zeile ergänzt werden, um die Verbindung zur MySQL-Datenbank zu erstellen: ```none compile('mysql:mysql-connector-java') ``` Anschließend sind einige Eigenschaften in der PROPERTIES-Datei „application“ hinzuzufügen. Zu finden ist diese Datei unter dem Pfad *\\src\\main\\resources* im Spring-Boot-Projekt-Verzeichnis. Öffnen Sie diese Textdatei und fügen Sie folgende Konfigurationszeilen ein: ```none spring.datasource.driverClassName = com.mysql.jdbc.Driver spring.datasource.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true spring.datasource.username = root spring.datasource.password = root spring.datasource.tomcat.testOnBorrow = true spring.datasource.tomcat.testWhileIdle = true spring.datasource.tomcat.timeBetweenEvictionRunsMillis = 60000 spring.datasource.tomcat.minEvictableIdleTimeMillis = 30000 spring.datasource.tomcat.validationQuery = SELECT 1 spring.datasource.tomcat.max-active = 15 spring.datasource.tomcat.max-idle = 10 spring.datasource.tomcat.max-wait = 8000 ``` Nun können Sie MySQL auf gewohntem Wege nutzen, um eine **Datenbank** inklusive der gewünschten **Datentabellen zu erstellen** – falls Sie dies nicht bereits getan haben. Einsteiger finden detaillierte Informationen über die Verwendung des relationalen Datenbank-Management-Systems in unserem umfangreichen [MySQL-Tutorial](https://www.ionos.at/digitalguide/server/knowhow/mysql-lernen-leicht-gemacht/). ### SSL/TLS-Zertifikat generieren und HTTPS aktivieren Standardmäßig nutzt eine erstellte Spring-Boot-Anwendung das ungesicherte Protokoll HTTP und den [TCP-Port](https://www.ionos.at/digitalguide/server/knowhow/tcp-und-udp-ports/ "TCP und UDP-Ports") 8080 für die Verbindung zum jeweiligen Webserver. Um stattdessen das **gesicherte HTTPS** und den hierfür vorgesehenen **TCP-Port 443** zur Standardwahl zu machen, benötigen Sie ein [SSL-Zertifikat](https://www.ionos.at/digitalguide/websites/webseiten-erstellen/ssl-zertifikat/ "SSL-Zertifikat") sowie die passenden Eigenschaften in der „application“-PROPERTIES-Datei. Ersteres erhalten Sie wahlweise von einer Zertifizierungsstelle oder indem Sie ein **selbstsigniertes Zertifikat mithilfe der Java-Laufzeitumgebung erstellen**. Diese hat mit dem Management Utility Key Tool ein Kommandozeilen-Werkzeug parat, mit dem Sie ganz unkompliziert PKCS12-Dateien (enthalten X.509-Zertifikat und privaten Schlüssel) für Server wie Tomcat, Exchange, IIS etc. erstellen können. Wenn Sie beispielsweise einen **Tomcat-Server** nutzen, geben Sie in die Eingabeaufforderung bzw. in das Terminal folgenden Befehl ein, um die **Schlüsselspeicherdatei für Ihre Spring-Boot-Applikation** zu generieren: ```none keytool -genkeypair -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650 ``` Zur **Personalisierung des Zertifikats** vergeben Sie im Anschluss ein individuelles Passwort und machen einige Angaben zu Ihrer Person, zu Ihrem Unternehmen sowie zu Ihrem Standort: [![Bild: Generierung eines selbstsignierten SSL/TLS-Zertifikats über die Windows-Eingabeaufforderung](https://www.ionos.at/digitalguide/fileadmin/_processed_/a/a/csm_generierung-selbstsigniertes-ssl-tls-zertifikat_d5970d62ba.webp "Generierung eines selbstsignierten SSL/TLS-Zertifikats über die Windows-Eingabeaufforderung")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2019/generierung-selbstsigniertes-ssl-tls-zertifikat.jpg) Generierung eines selbstsignierten SSL/TLS-Zertifikats über die Windows-Eingabeaufforderung Die Schlüsselspeicherdatei wird in der Folge automatisch in dem Verzeichnis abgelegt, in dem Sie den Befehl ausgeführt haben (in diesem Spring-Boot-Tutorial: im eigenen Benutzerverzeichnis). Kopieren Sie die „keystore“-Datei in das Verzeichnis Ihrer Spring-Boot-Applikation und erweitern Sie die bereits bei der Datenbank-Einbindung benötigte „application“-PROPERTIES-Datei um folgende Zeilen: ```none server.port = 443 server.ssl.key-store = C:/demo/keystore.p12 server.ssl.key-store-password = springboot server.ssl.key-store-type = PKCS12 server.ssl.key-alias = tomcat ``` Erstellen Sie abschließend eine neue ausführbare JAR-Datei, die wie konfiguriert via HTTPS mit Tomcat verbindet, mithilfe des folgenden Befehls: ```none mvn -Dmaven.test.skip=true -DskipTests=true clean install ``` ### Debugging der Spring-Boot-App mit Spring Cloud Sleuth und Zipkin vereinfachen Das **ständige Testen** gehört zu den wichtigsten Aufgaben bei der Software-Entwicklung, denn nur auf diese Weise lassen sich alle Fehler, die bei der Programmierung entstehen, ausfindig machen und beheben. Das Auswerten von Log-Dateien ist allerdings in der Regel sehr komplex, was den **Debugging-Prozess häufig sehr aufwendig** macht – insbesondere bei Microservices. Zum Abschluss des Spring-Boot-Tutorials wollen wir daher die Tracing-Lösungen [Spring Cloud Sleuth](https://spring.io/projects/spring-cloud-sleuth "Informationsseite zu Spring Cloud Sleuth") und [Zipkin](https://zipkin.io/ "Distributed Tracing System: OpenZipkin") einrichten, um die Spring-Boot-Applikation rundum zu überwachen. Mithilfe der beiden Tracing-Anwendungen können Sie alle Requests über einen zuvor eingerichteten [REST-Controller](https://spring.io/guides/gs/rest-service "RESTful Webservice mit Spring Boot erstellen") problemlos nachverfolgen und jederzeit den zeitlichen Ablauf darstellen. **Schritt 1: Spring Cloud Sleuth zum Projekt hinzufügen** Binden Sie zunächst das Sleuth-Modul in Ihre Spring-Boot-Applikation ein, indem Sie die Abhängigkeit in der Build-Konfigurationsdatei setzen. Fügen Sie hierfür folgenden Inhalt in die *pom.xml* ein, wenn Sie **Maven** nutzen: ```none org.springframework.cloud spring-cloud-starter-sleuth ${spring-cloud-sleuth.version} pom import ``` In der Konfigurationsdatei von **Gradle-Projekten** gilt es, folgende Zeile hinzuzufügen: ```none compile('org.springframework.cloud:spring-cloud-starter-sleuth') ``` **Schritt 2: Sleuth-Logs in die Klassendatei des REST-Controllers einbinden** Der REST-Controller Ihrer Spring-Boot-Anwendung muss nun so konfiguriert werden, dass er die Log-Dateien von Sleuth wie gewünscht verarbeitet. Fügen Sie der *.class*-Datei des Controllers zu diesem Zweck folgenden Konfigurationstext hinzu – der Paketname (hier *spring-boot-tutorial*) entspricht dabei der Domäne der <groupid> in der *pom.xml*:</groupid> ```none package spring-boot-tutorial.sleuth; import java.util.logging.Level; import java.util.logging.Logger; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @SpringBootApplication @RestController public class SleuthappApplication { private static final Logger LOG = Logger.getLogger(SleuthappApplication.class.getName()); public static void main(String[] args) { SpringApplication.run(SleuthappApplication.class, args); } @RequestMapping("/") public String index() { LOG.log(Level.INFO, "Index API is calling"); return "Sleuth: Spring-Boot-Tutorial-Test!"; } } ``` **Schritt 3: Name der Spring-Anwendung in den Eigenschaften aufführen** Um sicherzustellen, dass der Name der Spring-Boot-Applikation in Zipkin korrekt angezeigt wird, sollten Sie den Namen in der „application“-PROPERTIES-Datei angeben. Speichern Sie die Konfiguration auf einem Spring-Cloud-Konfigurationsserver, ist selbiges in der PROPERTIES-Datei „bootstrap“ zu erledigen: ```none spring.application.name = Spring-Boot-Tutorial-App ``` **Schritt 4: Zipkin zum Projekt hinzufügen** Zipkin hilft dabei, die Sleuth-Logs zu überwachen und zu verwalten, wobei sich die Open-Source-Software aus einem User-Interface und einer Serverkomponente zusammensetzt. Für beides werden Abhängigkeiten in der jeweiligen Build-Konfigurationsdatei hinzugefügt. **Maven-User** setzen hierfür folgenden Inhalt in die *pom.xml* ein: ```none io.zipkin.java zipkin-server io.zipkin.java zipkin-autoconfigure-ui runtime ``` In der **Gradle-Konfiguration** sehen die neuen Zeilen wie folgt aus: ```none compile('io.zipkin.java:zipkin-autoconfigure-ui') compile('io.zipkin.java:zipkin-server') ``` **Schritt 5: Der Applikation ermöglichen, als Zipkin-Server zu agieren** Im nächsten Schritt sorgen Sie dafür, dass Ihr Spring-Boot-Projekt als Zipkin-Server agieren kann. Hierfür erstellen Sie eine Datei mit dem Namen *zipkin.properties* und fügen dort folgende Zeilen ein: ```none spring.application.name=zipkin server.port=9411 logging.level.org.springframework.web=debug ``` Anschließend aktivieren Sie in der Java-Datei des Projekts die Server-Komponente: ```none package spring-boot-tutorial.zipkin; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import zipkin.server.EnableZipkinServer; @SpringBootApplication @EnableZipkinServer public class ZipkinappApplication { public static void main(String[] args) { SpringApplication.run(ZipkinappApplication.class, args); } } ``` Erzeugen Sie auf dem gewohnten Wege die ausführbare JAR-Datei und führen Sie die Applikation anschließend aus, ist der Zipkin-Server unter der Adresse “*http://localhost:9411/zipkin*” zu erreichen. **Schritt 6: Spring-Cloud-Zipkin-Abhängigkeit hinzufügen** Fügen Sie eine letzte Abhängigkeit in der Build-Konfigurationsdatei hinzu, um Sleuth und Zipkin zu verknüpfen. **Maven**: ```none org.springframework.cloud spring-cloud-sleuth-zipkin ``` **Gradle**: ```none compile('org.springframework.cloud:spring-cloud-sleuth-zipkin') ``` **Schritt 7: Sleuth-Log-Export auf den Zipkin-Server konfigurieren** Erweitern Sie die Java-Datei Ihrer Spring-Boot-Anwendung um das AlwaysSampler-Objekt (Bean), um den automatischen Export der Sleuth-Logs auf den Zipkin-Server zu aktivieren: ```none @Bean public AlwaysSampler defaultSampler() { return new AlwaysSampler(); } ``` **Schritt 8: Basis-URL des Zipkin-Servers in „application“-PROPERTIES angeben** Im letzten Schritt geben Sie die Basis-URL des Zipkin-Servers in den Applikations-Eigenschaften an, indem Sie ein weiteres Mal die PROPERTIES-Datei Ihres Spring-Boot-Projekts öffnen und folgende Zeile hinzufügen: ```none spring.zipkin.baseUrl = http://localhost:9411/zipkin/ ``` This is a markdown version of: [https://www.ionos.at/digitalguide/websites/web-entwicklung/spring-boot-tutorial/](https://www.ionos.at/digitalguide/websites/web-entwicklung/spring-boot-tutorial/) for AI/LLM consumption.