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.

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 (Web Application Archive) erforderlich ist
  • vereinfachte Maven-Konfiguration dank „Starter“-POMs (Project Object Models)
  • 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.

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:

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

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“:

Ausführen lässt sie sich mithilfe von Java, indem Sie folgenden Befehl eintippen:

java -jar demo-0.0.1-SNAPSHOT.jar

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:

 

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

Gradle-User erledigen diesen Schritt durch das Einfügen des folgenden Eintrags in die build.gradle-Datei:

compile('org.springframework.boot:spring-boot-starter-jdbc')
Hinweis

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:

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
</dependency>

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:

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.

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/TLS-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:

 

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:

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:

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:

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 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:

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-sleuth</artifactId>
  <version>${spring-cloud-sleuth.version}</version>
  <type>pom</type>
  <scope>import</scope>
</dependency>

In der Konfigurationsdatei von Gradle-Projekten gilt es, folgende Zeile hinzuzufügen:

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:

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:

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:

<dependency>
  <groupId>io.zipkin.java</groupId>
  <artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
  <groupId>io.zipkin.java</groupId>
  <artifactId>zipkin-autoconfigure-ui</artifactId>
  <scope>runtime</scope>
</dependency>

In der Gradle-Konfiguration sehen die neuen Zeilen wie folgt aus:

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:

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:

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 localhost/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:

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

Gradle:

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:

@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:

spring.zipkin.baseUrl = http://localhost:9411/zipkin/

Auf dem Laufenden bleiben?

Jetzt für unseren Newsletter anmelden und gratis Online-Marketing Whitepaper für lokale Anbieter sichern!