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, 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.
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 (Web Application Archive) erforderlich ist
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.
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 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 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 ApacheTomcat (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- (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 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 oder 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.
Das WAR-Format erweitert JAR um verschiedene Webkomponenten wie die XML-Konfigurationsdatei web.xml, die den Bereitstellungsprozess beschreibt.
Tipp
Wollen Sie Ihr Spring-Boot-Projekt auf eigene Faust mit Maven und Gradle anlegen, können Sie sich an den Installationsanleitungen 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:
Die Maven-Konfigurationsdatei zeichnet sich durch den XML-typischen Aufbau aus, der wichtige Metadaten voranstellt.
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:
mvn clean install
Maven funktioniert nach dem Modell „Konvention vor Konfiguration“, weshalb grundlegende Einstellungen wie das Ausgabeformat JAR beim Build-Prozess automatisch angewendet werden, sofern Sie keine spezifischen Anweisungen geben.
Für Gradle-Projekte lautet der Befehl indes folgendermaßen:
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“:
Die Erstellung der Archivdateien kann einige Minuten lang dauern – je nachdem, wie viele Abhängigkeiten Sie zuvor mit dem Spring Initializr hinzugefügt haben.
Ausführen lässt sie sich mithilfe von Java, indem Sie folgenden Befehl eintippen:
java -jar demo-0.0.1-SNAPSHOT.jar
Damit der Start der Spring-Boot-Applikation funktioniert, müssen Sie den aufgeführten Code im Ordner der JAR-Datei ausführen (target).
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:
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. 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 (Java Database Connectivity), 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:
Sie können die jeweilige Konfigurationsdatei mit jedem handelsüblichen Code-Editor ö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:
In der Gradle-Konfiguration muss folgende Zeile ergänzt werden, um die Verbindung zur MySQL-Datenbank zu erstellen:
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:
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.
SSL/TLS-Zertifikat generieren und HTTPS aktivieren
Standardmäßig nutzt eine erstellte Spring-Boot-Anwendung das ungesicherte Protokoll HTTP und den TCP-Port 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 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-Laufzeitumgebungerstellen. 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:
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:
Sind Sie sich hinsichtlich des Ländercodes unsicher, können Sie diesen auf der Website https://laendercode.net/de/ nachschlagen.
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:
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 und Zipkin 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 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:
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:
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:
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:
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:
Anschließend aktivieren Sie in der Java-Datei des Projekts die Server-Komponente:
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 "
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:
@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:
Apache Hadoop: verteilte Speicherarchitektur für große Datenmengen
KnowHow
Sie möchten komplexe Rechenprozesse mit großen Datenmengen durchführen? Das ist das Spezialgebiet des Big-Data-Frameworks Hadoop. Die Apache-Software mit Open-Source-Status bietet einen auf Java basierenden Rahmen, mit dem sich diverse Big-Data-Anwendungen auf Rechnerclustern parallelisieren lassen. Dabei glänzt sie durch modulare Erweiterbarkeit, die einen enormen Funktionsumfang für den Nutzer...
Frameworks sind aus dem Web-Engineering nicht mehr wegzudenken. Statt Anwendungen von Grund auf neu zu schreiben, können sich Programmierer bei der objektorientierten Software-Entwicklung auf bewährte Programmgerüste aus vordefinierten Klassen und Methoden stützen. Die Auswahl eines geeigneten Webframeworks ist jedoch alles andere als einfach. Wir erklären, wie ein solches Rahmenwerk funktioniert...
Spring – das Framework für komplexe Java-Applikationen
Web-Entwicklung
Java spielt in der einfachen Webentwicklung keine große Rolle, obwohl die Programmiersprache durchaus ihren Reiz hat. Vor allem bei der Gestaltung von Backends für Businessanwendungen hat sich die einst von Browsern unterstützte Sprache als effiziente Lösung etabliert. Das Spring-Framework enthält verschiedene Module, die als Grundbasis für komplexe Web- und Desktopanwendungen dienen und das...
CodeIgniter – das Leichtgewicht unter den PHP-Frameworks
Web-Entwicklung
CodeIgniter ist ein von EllisLab entwickeltes, quelloffenes PHP-Framework, das aktuell unter der Schirmherrschaft des British Columbia Institute of Technology steht. Die schlanke Software ist an das MVC-Architekturmuster angelehnt, wird für ihre gute Performance gelobt und besticht durch eine ausführliche Dokumentation. Wir stellen Aufbau, Struktur und Anwendungsfluss des CodeIgniter Frameworks...
Klassischerweise wird eine Client-Server-Verbindungen im Frage-Antwort-Muster durch HTTP durchgeführt. Wenn neue Daten geladen werden sollen, erfolgt eine Anfrage vom Client an den Server. Dieser prüft die Anforderung und sendet eine Antwort an den Client. Erst jetzt werden die Daten sichtbar. Mit WebSocket als bidirektionale Verbindung lässt sich dieser Prozess deutlich schneller auch ohne...