Zahlenraten 7: Spring Boot und ein Web-Client
Unser JsonServer hat gut 150 Zeilen. Die meisten davon haben mit Zahlenraten
nichts zu tun: Pfade zerlegen, Rümpfe lesen, Header setzen, Exceptions in
Statuscodes übersetzen. Genau das nimmt einem ein Framework ab. Das
bekannteste in Java ist Spring Boot.
Dieser Teil ist fertig: Projekt laden, starten, im Browser spielen – und dann lesen, wie wenig Code es braucht.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- erklären, was ein Framework übernimmt und was bei dir bleibt
- einen REST-Controller mit Spring lesen
- eine Spring-Boot-Anwendung starten und als JAR bauen
- eine HTML-Seite mit JavaScript gegen dein Protokoll sprechen lassen
Demo-Code: zahlenraten-7
⤓ zahlenraten-7.zip herunterladenDer fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.
Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner zahlenraten-7 wählen → OK → Trust Project. IntelliJ erkennt die pom.xml und lädt die Bibliotheken selbst herunter – das dauert beim ersten Mal einen Moment.
Enthält: pom.xml, EntfernterSpielleiterTest.java, LokalerSpielleiterTest.java, SpielTest.java, Antwort.java, EntfernterSpielleiter.java, Fehler.java, GemeinerSpielleiter.java, Hinweis.java, Konsole.java, LokalerSpielleiter.java, Spiel.java, SpielNichtGefunden.java, Spielleiter.java, Spielstart.java, Start.java, Versuch.java, Fehlerbehandlung.java, RateController.java, ZahlenratenAnwendung.java, application.properties, index.html, raten.js, stil.css
Das Projekt enthält den ganzen Kern aus den Teilen 2 bis 6 – Spiel, die
Spielleiter, die Konsole und den EntfernterSpielleiter. Statt JsonServer und
ServerStart gibt es ein Package spring und eine Web-Seite.
Starten
Abschnitt betitelt „Starten“Öffne das Projekt in IntelliJ, warte, bis Maven alles geladen hat, und starte
ZahlenratenAnwendung. Nach einer Sekunde steht in der Konsole:
… Tomcat started on port 8080 (http) with context path '/'… Started ZahlenratenAnwendung in 0.805 seconds (process running for 0.998)Dann im Browser http://localhost:8080 öffnen – und spielen.
Ohne IntelliJ geht es auch: mvn package baut ein JAR, in dem alles steckt, auch
der Webserver.
mvn packagejava -jar target/zahlenraten-1.0-SNAPSHOT.jarDie pom.xml
Abschnitt betitelt „Die pom.xml“<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion>
<!-- Spring Boot gibt die Versionen aller Bibliotheken vor, die zusammenpassen --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>4.1.2</version> <relativePath/> </parent>
<groupId>de.drv</groupId> <artifactId>zahlenraten</artifactId> <version>1.0-SNAPSHOT</version>
<properties> <java.version>21</java.version> </properties>
<dependencies> <!-- Webserver, Routing und JSON in einem --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webmvc</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies>
<build> <plugins> <!-- ein ausführbares JAR mit allem: java -jar target/zahlenraten-1.0-SNAPSHOT.jar --> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
</project>- Der Parent
spring-boot-starter-parentgibt die Versionen aller Bibliotheken vor, die zueinander passen. Deshalb steht bei den Abhängigkeiten keine Version. spring-boot-starter-webmvcbringt einen Webserver (Tomcat), das Routing und Jackson mit. Jackson 3 – dasselbe wie in Teil 5.- Das Plugin baut das ausführbare JAR.
Die Anwendung
Abschnitt betitelt „Die Anwendung“package de.drv.zahlenraten.spring;
import de.drv.zahlenraten.LokalerSpielleiter;import de.drv.zahlenraten.Spielleiter;
import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.context.annotation.Bean;
/** Der Zahlenraten-Server mit Spring Boot – startet einen Webserver auf Port 8080. */@SpringBootApplicationpublic class ZahlenratenAnwendung {
public static void main(String[] args) { SpringApplication.run(ZahlenratenAnwendung.class, args); }
/** Der Spielleiter, den Spring in den Controller hineinreicht. Für den Schummler: GemeinerSpielleiter. */ @Bean Spielleiter spielleiter() { return new LokalerSpielleiter(); }
}@SpringBootApplication sagt Spring: Durchsuche dieses Package nach Klassen mit
Spring-Annotationen und baue aus ihnen eine Anwendung.
Die Methode mit @Bean liefert ein Objekt, das Spring sich merkt – einen
Bean. Wer einen Spielleiter braucht, bekommt diesen. Das ist dieselbe Idee
wie unsere Start-Klasse: eine Stelle nennt die Implementierung beim Namen.
Wer gegen den Schummler spielen will, ändert nur diese Zeile.
Der Controller
Abschnitt betitelt „Der Controller“package de.drv.zahlenraten.spring;
import de.drv.zahlenraten.Antwort;import de.drv.zahlenraten.Spielleiter;import de.drv.zahlenraten.Spielstart;import de.drv.zahlenraten.Versuch;
import org.springframework.http.HttpStatus;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseStatus;import org.springframework.web.bind.annotation.RestController;
/** Dasselbe Protokoll wie der JsonServer aus Teil 5 – Routing und JSON übernimmt Spring. */@RestController@RequestMapping("/spiele")public class RateController {
private final Spielleiter spielleiter;
public RateController(Spielleiter spielleiter) { // Spring reicht den Bean herein this.spielleiter = spielleiter; }
/** POST /spiele → 201 {"id":…,"von":1,"bis":100} */ @PostMapping @ResponseStatus(HttpStatus.CREATED) public Spielstart neuesSpiel() { return spielleiter.neuesSpiel(); }
/** POST /spiele/{id}/versuche mit {"zahl":42} → 200 {"hinweis":"ZU_KLEIN","versuche":3} */ @PostMapping("/{spielId}/versuche") public Antwort rate(@PathVariable String spielId, @RequestBody Versuch versuch) { return spielleiter.rate(spielId, versuch.zahl()); }
}Vergleiche mit dem JsonServer:
JsonServer |
Spring |
|---|---|
createContext("/spiele", …) |
@RequestMapping("/spiele") |
methode.equals("POST") && pfad.equals("/spiele") |
@PostMapping |
regulärer Ausdruck, versuche.group(1) |
@PostMapping("/{spielId}/versuche") + @PathVariable |
lies(anfrage, Versuch.class) |
@RequestBody Versuch versuch |
antworte(anfrage, 201, start) |
Rückgabewert + @ResponseStatus(HttpStatus.CREATED) |
new JsonServer(spielleiter, 8080) |
Konstruktor-Parameter – Spring reicht den Bean herein |
Die Methoden sind so kurz wie die Methoden im Interface: Sie rufen nur noch den
Spielleiter auf. Alles andere erledigt Spring.
Die Fehler
Abschnitt betitelt „Die Fehler“package de.drv.zahlenraten.spring;
import de.drv.zahlenraten.Fehler;import de.drv.zahlenraten.SpielNichtGefunden;
import org.springframework.http.HttpStatus;import org.springframework.http.converter.HttpMessageNotReadableException;import org.springframework.web.bind.annotation.ExceptionHandler;import org.springframework.web.bind.annotation.ResponseStatus;import org.springframework.web.bind.annotation.RestControllerAdvice;
/** Exceptions → Statuscodes, wie das try/catch im JsonServer. Spring wählt den genauesten Typ. */@RestControllerAdvicepublic class Fehlerbehandlung {
@ExceptionHandler(SpielNichtGefunden.class) @ResponseStatus(HttpStatus.NOT_FOUND) public Fehler nichtGefunden(SpielNichtGefunden e) { return new Fehler(e.getMessage()); }
@ExceptionHandler(HttpMessageNotReadableException.class) @ResponseStatus(HttpStatus.BAD_REQUEST) public Fehler keinJson(HttpMessageNotReadableException e) { return new Fehler("Kein gültiges JSON"); }
@ExceptionHandler(IllegalArgumentException.class) @ResponseStatus(HttpStatus.BAD_REQUEST) public Fehler ungueltig(IllegalArgumentException e) { return new Fehler(e.getMessage()); }
@ExceptionHandler(IllegalStateException.class) @ResponseStatus(HttpStatus.CONFLICT) public Fehler vorbei(IllegalStateException e) { return new Fehler(e.getMessage()); }
}Das sind die catch-Blöcke aus dem JsonServer, jeder als eigene Methode.
@RestControllerAdvice heißt: gilt für alle Controller. Die Reihenfolge spielt
hier keine Rolle – Spring wählt bei einer SpielNichtGefunden von selbst den
genauesten Handler, nicht den für IllegalArgumentException.
HttpMessageNotReadableException ist Springs Name für Der Rumpf ließ sich nicht
lesen – also kein gültiges JSON. Jackson wirft darunter dieselbe
JacksonException wie in Teil 5.
Derselbe Client
Abschnitt betitelt „Derselbe Client“Das Protokoll ist dasselbe wie in Teil 5. Deshalb funktioniert die Konsole aus
Teil 6 unverändert: Start mit dem Argument http://localhost:8080 spielt gegen
den Spring-Server. Der Test beweist es – er ist derselbe wie in Teil 6, nur dass
Spring den Server startet:
package de.drv.zahlenraten;
import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;
import de.drv.zahlenraten.spring.ZahlenratenAnwendung;
import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.DisplayName;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Value;import org.springframework.boot.test.context.SpringBootTest;
/** Derselbe Test wie in Teil 6 – jetzt gegen den Spring-Server. */@SpringBootTest(classes = ZahlenratenAnwendung.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)class EntfernterSpielleiterTest {
@Value("${local.server.port}") private int port;
private EntfernterSpielleiter spielleiter;
@BeforeEach void verbinde() { spielleiter = new EntfernterSpielleiter("http://localhost:" + port); }
@Test @DisplayName("Halbieren findet die Zahl auch über Spring in höchstens sieben Versuchen") void halbieren() { for (int i = 0; i < 20; i++) { Antwort antwort = LokalerSpielleiterTest.halbiere(spielleiter, spielleiter.neuesSpiel()); assertEquals(Hinweis.RICHTIG, antwort.hinweis()); assertTrue(antwort.versuche() <= 7); } }
@Test @DisplayName("Dieselben Fehlercodes wie beim JsonServer") void fehler() { Spielstart start = spielleiter.neuesSpiel(); assertThrows(IllegalArgumentException.class, () -> spielleiter.rate(start.id(), 0)); assertThrows(SpielNichtGefunden.class, () -> spielleiter.rate("gibt-es-nicht", 50)); LokalerSpielleiterTest.halbiere(spielleiter, start); assertThrows(IllegalStateException.class, () -> spielleiter.rate(start.id(), 50)); }
}@SpringBootTest mit RANDOM_PORT startet die ganze Anwendung auf einem freien
Port – wie Port 0 beim JsonServer.
Der Web-Client
Abschnitt betitelt „Der Web-Client“Alles unter src/main/resources/static liefert Spring einfach aus: index.html
unter /, die anderen Dateien unter ihrem Namen. Die Seite kommt also vom selben
Server wie das Spiel.
<!doctype html><html lang="de"><head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1"> <title>Zahlenraten</title> <link rel="stylesheet" href="stil.css"></head><body> <h1>Zahlenraten</h1> <p id="aufgabe">Ich denke mir eine Zahl …</p>
<form id="formular"> <input id="zahl" type="number" min="1" max="100" required autofocus> <button>Raten</button> </form>
<div class="leiste"><div id="bereich"></div></div> <p id="hinweis"></p> <ol id="versuche"></ol>
<button id="neu" hidden>Noch eine Runde</button>
<script src="raten.js"></script></body></html>// Der Web-Client für Zahlenraten – dasselbe Protokoll wie EntfernterSpielleiter, in JavaScript.
let spiel = null; // {id, von, bis} vom Serverlet von = 1; // was nach den Hinweisen noch möglich istlet bis = 100;
/** Eine POST-Anfrage mit JSON. Fehlercodes werden zu einer Exception mit der Meldung des Servers. */async function post(pfad, nachricht) { const antwort = await fetch(pfad, { method: "POST", headers: { "Content-Type": "application/json" }, body: nachricht ? JSON.stringify(nachricht) : undefined, }); const rumpf = await antwort.json(); if (!antwort.ok) { throw new Error(rumpf.fehler); } return rumpf;}
async function neuesSpiel() { spiel = await post("/spiele"); von = spiel.von; bis = spiel.bis; document.getElementById("aufgabe").textContent = `Ich denke mir eine Zahl von ${spiel.von} bis ${spiel.bis}. Rate!`; document.getElementById("versuche").replaceChildren(); document.getElementById("hinweis").textContent = ""; document.getElementById("formular").hidden = false; document.getElementById("neu").hidden = true; zeigeBereich();}
document.getElementById("formular").onsubmit = async (ereignis) => { ereignis.preventDefault(); // nicht die Seite neu laden const feld = document.getElementById("zahl"); const zahl = Number(feld.value); feld.value = ""; try { const antwort = await post(`/spiele/${spiel.id}/versuche`, { zahl }); const text = { ZU_KLEIN: "zu klein", ZU_GROSS: "zu groß", RICHTIG: "richtig!" }[antwort.hinweis]; const eintrag = document.createElement("li"); eintrag.textContent = `${zahl} – ${text}`; document.getElementById("versuche").append(eintrag);
if (antwort.hinweis === "ZU_KLEIN") { von = Math.max(von, zahl + 1); } else if (antwort.hinweis === "ZU_GROSS") { bis = Math.min(bis, zahl - 1); } else { von = bis = zahl; document.getElementById("hinweis").textContent = `Richtig! ${antwort.versuche} Versuche.`; document.getElementById("formular").hidden = true; document.getElementById("neu").hidden = false; } if (antwort.hinweis !== "RICHTIG") { document.getElementById("hinweis").textContent = `Die Zahl liegt zwischen ${von} und ${bis}.`; } zeigeBereich(); } catch (e) { document.getElementById("hinweis").textContent = e.message; }};
/** Ein Balken, der zeigt, welcher Teil von 1 bis 100 noch übrig ist. */function zeigeBereich() { const bereich = document.getElementById("bereich"); bereich.style.marginLeft = `${von - 1}%`; bereich.style.width = `${bis - von + 1}%`;}
document.getElementById("neu").onclick = neuesSpiel;neuesSpiel();postist derEntfernterSpielleiterin JavaScript:fetchschickt die Anfrage,JSON.stringifyundantwort.json()übernehmen die Rolle von Jackson. Ein Fehlercode wird zu einer Exception mit der Meldung des Servers – wie inpruefe.awaitwartet auf die Antwort, ohne die Seite einzufrieren.- Der blaue Balken zeigt, welcher Teil von 1 bis 100 nach den Hinweisen noch möglich ist. Beim Halbieren wird er mit jedem Versuch halb so breit.
stil.css
body { font-family: system-ui, sans-serif; margin: 2rem; max-width: 32rem; color: #1f2933;}
input, button { font: inherit; padding: 0.3rem 0.6rem;}
input { width: 6rem;}
.leiste { margin: 1rem 0; height: 1rem; background: #e4e7eb; border-radius: 0.5rem; overflow: hidden;}
#bereich { height: 100%; background: #2f80ed; transition: all 0.3s;}
#hinweis { font-weight: 600;}Und Jakarta EE?
Abschnitt betitelt „Und Jakarta EE?“Neben Spring gibt es einen Standard für dasselbe: Jakarta EE, früher Java EE. Die Annotationen heißen anders, die Idee ist dieselbe:
| Spring Boot | Jakarta REST (JAX-RS) |
|---|---|
@RestController + @RequestMapping("/spiele") |
@Path("/spiele") |
@PostMapping("/{spielId}/versuche") |
@POST + @Path("/{spielId}/versuche") |
@PathVariable |
@PathParam |
@RequestBody |
ein Parameter ohne Annotation |
@ExceptionHandler |
ein ExceptionMapper |
@Bean |
@Produces (CDI) |
So sähe der Controller dort aus – nur zum Lesen:
@Path("/spiele")public class RateRessource {
@Inject Spielleiter spielleiter;
@POST public Response neuesSpiel() { return Response.status(201).entity(spielleiter.neuesSpiel()).build(); }
@POST @Path("/{spielId}/versuche") public Antwort rate(@PathParam("spielId") String spielId, Versuch versuch) { return spielleiter.rate(spielId, versuch.zahl()); }}Ein Jakarta-Programm läuft in einem Anwendungsserver wie WildFly, Payara oder Open Liberty – oder mit einem eingebauten Server, etwa mit Quarkus oder Helidon. Es ist dasselbe Muster wie bei JDBC: Jakarta EE ist eine Spezifikation, die Server sind ihre Implementierungen.
Zum Ausprobieren
Abschnitt betitelt „Zum Ausprobieren“Es gibt keine Lösungen – alles ist schon da. Wer weitermachen will:
-
Zwei Clients, ein Server: Spiele im Browser und gleichzeitig mit
Start http://localhost:8080auf der Konsole. Beide sprechen mit demselbenLokalerSpielleiter– jeder mit seinem eigenen Spiel. -
Der Schummler im Browser: Lass den
@BeaneinenGemeinerSpielleiterliefern. Was ändert sich am Controller, an der Seite, am Test? Läuft der Test noch? -
Ein Spiel abfragen: Ein neuer Endpunkt
GET /spiele/{spielId}, der sagt, wie viele Versuche es schon gab und ob das Spiel vorbei ist. Was fehlt dafür imSpielleiter-Interface – und welche Klassen müssen es dann alle erfüllen? -
Für Schnelle – eine Bestenliste: Der Server merkt sich die besten Runden. Ein Name kommt aus einem Eingabefeld der Seite, die Liste zeigt die Seite unter dem Spiel an. Wohin gehört die Liste: in den Controller, in den Spielleiter oder in eine eigene Klasse?