Zum Inhalt springen

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.

  • 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 herunterladen

Der 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.

Öffne das Projekt in IntelliJ, warte, bis Maven alles geladen hat, und starte ZahlenratenAnwendung. Nach einer Sekunde steht in der Konsole:

Terminal-Fenster
… 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.

Terminal-Fenster
mvn package
java -jar target/zahlenraten-1.0-SNAPSHOT.jar
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-parent gibt die Versionen aller Bibliotheken vor, die zueinander passen. Deshalb steht bei den Abhängigkeiten keine Version.
  • spring-boot-starter-webmvc bringt einen Webserver (Tomcat), das Routing und Jackson mit. Jackson 3 – dasselbe wie in Teil 5.
  • Das Plugin baut das ausführbare JAR.
ZahlenratenAnwendung.java
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. */
@SpringBootApplication
public 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.

RateController.java
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.

Fehlerbehandlung.java
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. */
@RestControllerAdvice
public 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.

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:

EntfernterSpielleiterTest.java
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.

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.

index.html
<!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>
raten.js
// Der Web-Client für Zahlenraten – dasselbe Protokoll wie EntfernterSpielleiter, in JavaScript.
let spiel = null; // {id, von, bis} vom Server
let von = 1; // was nach den Hinweisen noch möglich ist
let 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();
  • post ist der EntfernterSpielleiter in JavaScript: fetch schickt die Anfrage, JSON.stringify und antwort.json() übernehmen die Rolle von Jackson. Ein Fehlercode wird zu einer Exception mit der Meldung des Servers – wie in pruefe.
  • await wartet 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
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;
}

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.

Es gibt keine Lösungen – alles ist schon da. Wer weitermachen will:

  1. Zwei Clients, ein Server: Spiele im Browser und gleichzeitig mit Start http://localhost:8080 auf der Konsole. Beide sprechen mit demselben LokalerSpielleiter – jeder mit seinem eigenen Spiel.

  2. Der Schummler im Browser: Lass den @Bean einen GemeinerSpielleiter liefern. Was ändert sich am Controller, an der Seite, am Test? Läuft der Test noch?

  3. 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 im Spielleiter-Interface – und welche Klassen müssen es dann alle erfüllen?

  4. 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?