Spring Boot 3

2Hallo, Spring Boot

Im ersten Kapitel bauen wir direkt eine lauffähige »Hello World«-Anwendung, um mit einem Erfolgserlebnis zu starten.

2.1Einleitung

Dieses Buch ist ein Praxisbuch. In fast allen Kapiteln werden wir anhand von Codebeispielen die verschiedenen Aspekte einer Spring-Boot-Anwendung diskutieren. In den meisten Kapiteln sind diese Codebeispiele einer Beispielanwendung entnommen, deren Code auf GitHub öffentlich verfügbar ist. Wir laden dazu ein, den Beispielcode beim Lesen des Buches in der lokalen IDE durchzustöbern.

In diesem Sinne beginnen wir dieses Buch auch mit einem praktischen »Hello World«-Beispiel. Leser, die bereits Erfahrung mit Spring Boot haben, können dieses Kapitel guten Gewissens überspringen. Wenn nicht, laden wir dazu ein, den Beispielen in diesem Kapitel zu folgen und eine erste lauffähige Spring-Boot-Anwendung zu bauen.

In diesem Kapitel werden wir nicht jedes kleine Detail erläutern. Aber keine Angst, wir verweisen stets auf spätere Kapitel, in denen die Details vertieft werden.

2.2JDK installieren

Um eine Spring-Boot-Anwendung zu entwickeln, müssen wir ein JDK (Java Development Kit) auf unserem Rechner installieren. Spring Boot 3 benötigt ein JDK der Version 17 oder höher. Wenn Sie bereits ein solches JDK installiert haben, können Sie mit dem nächsten Abschnitt fortfahren.

Wir empfehlen zur Verwaltung des JDK einen Runtime Manager wie asdf1, jEnv2 oder SDKMan3. Diese Tools machen es einfach, zwischen verschiedenen Versionen eines JDK hin- und herzuwechseln. SDKMan und asdf automatisieren darüber hinaus auch das Herunterladen von verschiedenen JDK-Versionen. Wir können mit einem einzigen Kommandozeilenbefehl ein bestimmtes JDK herunterladen oder bestimmen, welches der bereits heruntergeladenen JDKs wir gerade benutzen möchten.

Zur Installation der Runtime Manager verweisen wir auf die Websites der Tools. Im Folgenden zeigen wir, wie wir mit asdf ein JDK installieren, das wir für alle Beispiele in diesem Buch benutzen können.

Vorausgesetzt, asdf ist erfolgreich installiert, müssen wir zunächst das Java-Plugin installieren (asdf unterstützt nämlich auch Runtimes anderer Programmiersprachen):

> asdf plugin add java

Dann können wir zum Beispiel mit dem folgenden Befehl ein JDK installieren:

> asdf install java latest:corretto

Hier installieren wir die aktuelle Version des Amazon-Corretto-JDK. Wir können uns auch eine Liste aller anderen JDKs anzeigen lassen und dann eines von denen installieren:

> asdf list all java | grep \\-21\\.

Diese Liste ist sehr lang, sodass wir sie hier mithilfe von grep auf die JDKs der Version 21 filtern.

Nun, da wir ein JDK installiert haben (oder mehrere), müssen wir unsere Umgebung noch so konfigurieren, dass dieses JDK auch überall genutzt wird:

> asdf local java latest:corretto

Der Befehl java --version sollte nun die erwartete Version des JDK ausgeben.

2.3Kickstart mit dem Spring Initializr

Nun können wir unser Beispielprojekt erstellen. Das geht am einfachsten mit dem Spring Initializr, der unter https://start.spring.io/ verfügbar ist. Hier können wir einige Parameter, wie zum Beispiel die Java-Version, auswählen und uns eine ZIP-Datei mit einem Projektskelett erstellen lassen. Wir werden den Spring Initializr im Rest dieses Buches noch häufig verwenden, um Beispielprojekte für unterschiedliche Anwendungsfälle zu generieren.

Für unser »Hello World«-Beispielprojekt wählen wir die folgenden Parameter:

• Project: Gradle-Kotlin
• Language: Java
• Spring Boot: aktuelle 3.x-Version (Standardeinstellung)
• Dependencies: Spring Web

Alle anderen Einstellungen belassen wir mit ihren Standardwerten. Über den Button »Add Dependencies« können wir eine Auswahl bestimmter Integrationen und Features auswählen, die unserem Projekt dann als Dependencies hinzugefügt werden. Wir wählen zu Beginn nur die »Spring Web«-Dependency, um eine einfache Webanwendung zu entwickeln.

Mit einem Klick auf den »Generate«-Button lassen wir uns das Projekt erstellen und laden die ZIP-Datei herunter, die wir auf unserer Festplatte entpacken. Dann laden wir den Ordner als Projekt in unsere IDE und schauen uns im Projekt um.

2.4Projektstruktur

Die zentrale Datei im Projektordner ist die Datei build.gradle.kts, unser Gradle-Build-Skript. Es ist in der Kotlin-DSL geschrieben, weil wir bei Erstellung des Projekts »Gradle-Kotlin« ausgewählt haben. Wir können auch »Gradle-Groovy« wählen, um das Skript in Groovy zu erstellen, oder »Maven«, um Maven als Build-Tool zu nutzen und eine pom.xml-Datei zu erzeugen.

Im Build-Skript finden wir eine Dependency zum Modul spring-boot-starter-web, das uns alle Features mitbringt, um eine Webanwendung zu entwickeln. Wir finden außerdem eine Dependency zum Modul spring-boot-starter-test, das uns einige Testwerkzeuge zur Verfügung stellt, die wir später im Testing-Kapitel noch genauer betrachten.

Das Build-Skript konfiguriert darüber hinaus die Plugins org.spring-framework.boot und io.spring.dependency-management, über die wir in Kapitel 6 noch mehr lernen.

Wir finden des Weiteren die Dateien gradlew und gradlew.bat und den Ordner gradle, die alle zum Gradle Wrapper4 gehören. Die gradlew-Skripte können wir nutzen, um Gradle aufzurufen, ohne Gradle lokal installieren zu müssen. Sie prüfen, ob eine Gradle-Installation verfügbar ist, und laden sie, falls erforderlich, herunter. So können wir unser Projekt auf unterschiedlichen Rechnern laufen lassen, ohne auf jedem Rechner Gradle installieren zu müssen. Wir werden unser Projekt später mit ./gradlew build bauen.

Im src-Ordner finden wir genau drei Dateien:

• DemoApplication.java: Diese Klasse ist der Einstiegspunkt zu unserer Spring-Boot-Anwendung. Sie ist mit der Annotation @SpringBootApplication versehen, die wir in Kapitel 4 genauer untersuchen. Wird die main()-Methode dieser Klasse aufgerufen, startet unsere Anwendung.
• application.properties: Dies ist die zentrale Konfigurationsdatei für unsere Anwendung. Diese Datei ist leer, weil unsere Anwendung aktuell mit der Standardkonfiguration von Spring Boot zufrieden ist. Wir schauen uns die Konfiguration einer Spring-Boot-Anwendung im Detail in Kapitel 5 an.
• DemoApplicationTests.java: Diese Klasse ist mit der Annotation @SpringBootTest versehen. Diese sorgt dafür, dass unsere Anwendung für jede @Test-Methode gestartet wird. Die leere Test-Methode contextLoads() hat augenscheinlich keinen Effekt, da unsere Anwendung aber für diesen Test gestartet wird, prüft dieser leere Test implizit, dass unsere Anwendung fehlerfrei starten kann. Schleicht sich zum Beispiel ein Konfigurationsfehler ein, schlägt dieser Test fehl. Er gibt uns also eine gewisse Sicherheit, obwohl die Test-Methode leer ist. Wir beschäftigen uns mit den Details des Testing mit Spring Boot in Kapitel 7.

Das sind auch schon alle Dateien unserer Anwendung. Mehr braucht unsere Anwendung nicht, um zu starten.

2.5Die Anwendung bauen

Was macht man als Erstes, wenn man ein neues Projekt lokal untersucht? Richtig, man führt den Build-Prozess aus, um Vertrauen in das Projekt zu gewinnen. Erst wenn der Build-Prozess problemlos läuft, sollten wir damit anfangen, Änderungen am Projekt vorzunehmen.

In unserem Fall nutzen wir Gradle als Build-Werkzeug, und der Build-Befehl lautet wie folgt:

> ./gradlew build

Mit diesem Befehl starten wir den Gradle Wrapper, der bei Bedarf Gradle herunterlädt, den Code kompiliert, die Tests ausführt und ein Artefakt erzeugt, das unsere Anwendung beinhaltet. Der Build-Prozess sollte mit einem befriedigenden BUILD SUCCESSFUL quittiert werden, wenn alles wie erwartet funktioniert.

Gradle legt während des Builds den Ordner build an, der alle Ergebnisse des Build-Prozesses beinhaltet. Im Ordner build/libs finden wir eine Datei demo-0.0.1-SNAPSHOT.jar (der Name kann variieren, je nachdem, was man bei der Initialisierung des Projekts auf start.spring.io eingegeben hat). Diese Datei ist ein...