Schiffe versenken: Derselbe Server mit Spring Boot
Unseren Server haben wir selbst gebaut: Routing mit regulären Ausdrücken, JSON
mit Jackson, ein großes try/catch für die Statuscodes, ein Handler für die
Webseite. In echten Projekten schreibt das kaum jemand selbst – dafür gibt es
Frameworks. Das verbreitetste im Java-Umfeld ist Spring Boot.
Dieser Artikel baut den Server noch einmal – mit Spring Boot. Kern, Dienst, Protokoll, Java-Client und Web-Client bleiben genau so, wie sie sind. Am Ende spielt der Java-Client gegen den Spring-Server, ohne den Unterschied zu bemerken.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- erklären, was ein Framework ist und was Spring Boot einem abnimmt
- einen
@RestControllerlesen: Pfade, Methoden, Parameter, Antworten - erklären, was Dependency Injection heißt
- ein Spring-Boot-Programm starten – in IntelliJ und als ausführbares JAR
Demo-Code: 40-schiffe-spring
⤓ schiffe-spring.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 40-schiffe-spring 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, flotte.json, ClientStart.java, Feldanzeige.java, HttpSpieldienst.java, Konsole.java, UebungsDemo.java, AttrappenSpieldienst.java, Aufstellung.java, Beitritt.java, LokalerSpieldienst.java, SpielNichtGefunden.java, Spieldienst.java, Spielstand.java, Uebungsgegner.java, Nachrichten.java, Protokoll.java, Ergebnis.java, Flotte.java, Koordinate.java, Phase.java, Richtung.java, Schiff.java, Schiffstyp.java, Seite.java, Spiel.java, Fehlerbehandlung.java, SchiffeAnwendung.java, SpielController.java, application.properties, index.html, spiel.js, stil.css, HttpSpieldienstTest.java, KonsoleTest.java, FlotteTest.java, KoordinateTest.java, SpielTest.java
Das Demo-Projekt ist diesmal fertig: das ganze Spiel, nur mit Spring Boot statt
dem eigenen HttpServer. Zum Lesen, Starten und Vergleichen.
Bibliothek oder Framework?
Abschnitt betitelt „Bibliothek oder Framework?“Jackson ist eine Bibliothek: Wir rufen sie auf, wenn wir sie brauchen –
json.readValue(…). Spring Boot ist ein Framework: Es ruft uns auf. Wir
schreiben Klassen mit Annotationen, und Spring entscheidet, wann welche Methode
läuft – wenn eine passende Anfrage kommt.
Was im eigenen Server Handarbeit war, erledigt Spring:
| Aufgabe | eigener Server | Spring Boot |
|---|---|---|
| Server starten | HttpServer.create(…), createContext, setExecutor |
SpringApplication.run(…) – ein Tomcat-Server ist eingebaut |
| Routing | reguläre Ausdrücke und if in leiteWeiter |
@PostMapping("/{spielId}/schuesse") an der Methode |
| Pfad-Teile | matcher.group(1) |
@PathVariable String spielId |
| Header | getRequestHeaders().getFirst(…) |
@RequestHeader("X-Spieler") String token |
| JSON lesen | lies(anfrage, SchussAnfrage.class) |
@RequestBody SchussAnfrage |
| JSON schreiben | antworte(anfrage, 200, …) |
einfach return – Spring macht JSON daraus |
| Statuscode | Zahl in antworte |
@ResponseStatus(HttpStatus.CREATED) |
| Fehler → Status | ein großes try/catch |
@ExceptionHandler-Methoden |
| Webseite ausliefern | StatischeDateien |
Dateien in src/main/resources/static – sonst nichts |
Der eigene Server hatte 347 Zeilen in vier Klassen, der Spring-Server hat 203 in drei – Kommentare und Importe mitgezählt. Was übrig bleibt, ist vor allem die Übersetzung zwischen Nachrichten und fachlichen Typen: Die kann kein Framework übernehmen, denn sie gehört zu unserem Spiel.
Das Projekt
Abschnitt betitelt „Das Projekt“<?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>schiffe-spring</artifactId> <version>1.0-SNAPSHOT</version>
<properties> <java.version>21</java.version> </properties>
<dependencies> <!-- Webserver (Tomcat), Routing, JSON mit Jackson – alles in einem --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webmvc</artifactId> </dependency> <!-- JUnit und Werkzeuge zum Testen einer Spring-Anwendung --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies>
<build> <plugins> <!-- baut ein ausführbares JAR mit allen Bibliotheken: java -jar target/schiffe-spring-1.0-SNAPSHOT.jar --> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
</project><parent>: Spring Boot gibt die Versionen sehr vieler Bibliotheken vor, die zusammenpassen – Jackson, Tomcat, JUnit und viele mehr. Deshalb stehen bei den Abhängigkeiten keine Versionen.spring-boot-starter-webmvcbringt alles für einen Web-Server mit: Tomcat, das Routing, Jackson 3. Ein Starter ist eine Abhängigkeit, die viele andere mitbringt.spring-boot-maven-pluginbaut am Ende ein JAR, in dem alle Bibliotheken stecken – siehe unten.
de.drv.schiffe ├── spiel unverändert ├── dienst unverändert ├── protokoll unverändert ├── client unverändert └── spring NEU – statt server: SchiffeAnwendung, SpielController, Fehlerbehandlungsrc/main/resources ├── application.properties Einstellungen └── static/ die Webseite aus dem letzten Artikel, unverändertDie Anwendung und ein Bean
Abschnitt betitelt „Die Anwendung und ein Bean“package de.drv.schiffe.spring;
import de.drv.schiffe.dienst.LokalerSpieldienst;import de.drv.schiffe.dienst.Spieldienst;
import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.context.annotation.Bean;
/** * Der Server mit Spring Boot. {@code main} startet einen eingebauten Webserver (Tomcat) auf * Port 8080. Spring sucht im Package dieser Klasse nach Controllern und richtet alles selbst ein. */@SpringBootApplicationpublic class SchiffeAnwendung {
public static void main(String[] args) { SpringApplication.run(SchiffeAnwendung.class, args); }
/** * Ein <em>Bean</em>: ein Objekt, das Spring einmal erzeugt und überall dort hineinreicht, wo * ein {@link Spieldienst} gebraucht wird – hier in den {@link SpielController}. */ @Bean Spieldienst spieldienst() { return new LokalerSpieldienst(); }
}@SpringBootApplicationsagt: Hier beginnt eine Spring-Anwendung. Spring durchsucht das Package dieser Klasse – und alle darunter – nach Klassen mit Annotationen wie@RestController.@Beanan einer Methode heißt: Spring ruft sie einmal auf und merkt sich das Objekt. Wer einenSpieldienstbraucht, bekommt genau dieses.
Dependency Injection
Abschnitt betitelt „Dependency Injection“Im eigenen Server stand in ServerStart:
new SpielServer(new LokalerSpieldienst(), 8080).starte();Wir haben die Objekte selbst erzeugt und zusammengesteckt. Mit Spring schreibt
der Controller nur, was er braucht – einen Spieldienst im Konstruktor:
public SpielController(Spieldienst dienst) { this.dienst = dienst;}Spring erzeugt den Controller selbst und reicht den Bean hinein. Das heißt
Dependency Injection: Abhängigkeiten werden von außen hineingereicht, statt
dass eine Klasse sie selbst erzeugt. Die Idee kennen wir – Start beim
Zahlenraten und ClientStart haben genau das von Hand gemacht. Spring macht es
für eine ganze Anwendung.
Der Controller kennt dabei nur das Interface Spieldienst. Soll der Server mit
der Attrappe laufen, ändert sich eine Zeile – in der @Bean-Methode.
Der Controller
Abschnitt betitelt „Der Controller“package de.drv.schiffe.spring;
import de.drv.schiffe.dienst.Aufstellung;import de.drv.schiffe.dienst.Beitritt;import de.drv.schiffe.dienst.Spieldienst;import de.drv.schiffe.dienst.Spielstand;import de.drv.schiffe.protokoll.Nachrichten.BeitrittAntwort;import de.drv.schiffe.protokoll.Nachrichten.FlotteAnfrage;import de.drv.schiffe.protokoll.Nachrichten.SchiffNachricht;import de.drv.schiffe.protokoll.Nachrichten.SchussAnfrage;import de.drv.schiffe.protokoll.Nachrichten.SchussAntwort;import de.drv.schiffe.protokoll.Nachrichten.StandAntwort;import de.drv.schiffe.protokoll.Protokoll;import de.drv.schiffe.spiel.Ergebnis;import de.drv.schiffe.spiel.Koordinate;import de.drv.schiffe.spiel.Richtung;import de.drv.schiffe.spiel.Schiffstyp;
import org.springframework.http.HttpStatus;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.PutMapping;import org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.RequestHeader;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseStatus;import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;import java.util.List;import java.util.Map;import java.util.TreeMap;
/** * Dieselben fünf Endpunkte wie der eigene {@code SpielServer} – aber Routing, JSON lesen und * schreiben übernimmt Spring. Was bleibt, ist die Übersetzung zwischen Nachrichten und fachlichen * Typen. */@RestController@RequestMapping(Protokoll.SPIELE)public class SpielController {
private final Spieldienst dienst;
/** Spring übergibt hier den Bean aus {@link SchiffeAnwendung#spieldienst()}. */ public SpielController(Spieldienst dienst) { this.dienst = dienst; }
/** POST /spiele */ @PostMapping @ResponseStatus(HttpStatus.CREATED) public BeitrittAntwort neuesSpiel() { return alsNachricht(dienst.neuesSpiel()); }
/** POST /spiele/{id}/spieler */ @PostMapping("/{spielId}/spieler") @ResponseStatus(HttpStatus.CREATED) public BeitrittAntwort beitreten(@PathVariable String spielId) { return alsNachricht(dienst.beitreten(spielId)); }
/** PUT /spiele/{id}/flotte */ @PutMapping("/{spielId}/flotte") @ResponseStatus(HttpStatus.NO_CONTENT) public void aufstellen(@PathVariable String spielId, @RequestHeader(Protokoll.TOKEN_HEADER) String token, @RequestBody FlotteAnfrage nachricht) { if (nachricht.schiffe() == null) { throw new IllegalArgumentException("Es fehlt die Liste \"schiffe\""); } List<Aufstellung> flotte = new ArrayList<>(); for (SchiffNachricht schiff : nachricht.schiffe()) { flotte.add(new Aufstellung( Schiffstyp.valueOf(pflicht(schiff.typ(), "typ")), Koordinate.von(schiff.anfang()), Richtung.valueOf(pflicht(schiff.richtung(), "richtung")))); } dienst.aufstellen(spielId, token, flotte); }
/** POST /spiele/{id}/schuesse */ @PostMapping("/{spielId}/schuesse") public SchussAntwort schiessen(@PathVariable String spielId, @RequestHeader(Protokoll.TOKEN_HEADER) String token, @RequestBody SchussAnfrage nachricht) { Ergebnis ergebnis = dienst.schiessen(spielId, token, Koordinate.von(nachricht.feld())); return new SchussAntwort(ergebnis.name()); }
/** GET /spiele/{id} */ @GetMapping("/{spielId}") public StandAntwort stand(@PathVariable String spielId, @RequestHeader(Protokoll.TOKEN_HEADER) String token) { Spielstand stand = dienst.stand(spielId, token); return new StandAntwort(stand.phase().name(), stand.amZug(), alsText(stand.eigeneSchuesse()), alsText(stand.gegnerischeSchuesse()), stand.gewonnen()); }
// ----- Übersetzen – genau wie im eigenen Server -------------------------------------
private static BeitrittAntwort alsNachricht(Beitritt beitritt) { return new BeitrittAntwort(beitritt.spielId(), beitritt.token()); }
private static String pflicht(String wert, String name) { if (wert == null) { throw new IllegalArgumentException("Es fehlt \"" + name + "\""); } return wert; }
private static Map<String, String> alsText(Map<Koordinate, Ergebnis> schuesse) { Map<String, String> text = new TreeMap<>(); for (Map.Entry<Koordinate, Ergebnis> schuss : schuesse.entrySet()) { text.put(schuss.getKey().toString(), schuss.getValue().name()); } return text; }
}| Annotation | heißt |
|---|---|
@RestController |
Diese Klasse beantwortet HTTP-Anfragen. Was die Methoden zurückgeben, wird zu JSON. |
@RequestMapping("/spiele") |
Alle Pfade der Klasse beginnen mit /spiele. |
@PostMapping, @GetMapping, @PutMapping |
Methode und Pfad: Diese Java-Methode ist für POST /spiele/{spielId}/schuesse zuständig. |
@PathVariable |
ein Teil des Pfads, hier die spielId aus {spielId} |
@RequestHeader("X-Spieler") |
ein Header – fehlt er, antwortet Spring mit einem Fehler |
@RequestBody |
der Rumpf, als JSON in einen Record gelesen – mit Jackson |
@ResponseStatus(HttpStatus.CREATED) |
der Statuscode bei Erfolg, sonst 200 |
Die Methoden selbst sind kurz: Nachricht in fachliche Typen übersetzen, den Dienst aufrufen, das Ergebnis als Nachricht zurückgeben. Genau der Teil, der beim eigenen Server pro Endpunkt anders war – alles Gemeinsame steckt jetzt in Spring.
Die Fehlerbehandlung
Abschnitt betitelt „Die Fehlerbehandlung“package de.drv.schiffe.spring;
import de.drv.schiffe.dienst.SpielNichtGefunden;import de.drv.schiffe.protokoll.Nachrichten.Fehler;
import org.springframework.http.HttpStatus;import org.springframework.http.converter.HttpMessageNotReadableException;import org.springframework.web.bind.MissingRequestHeaderException;import org.springframework.web.bind.annotation.ExceptionHandler;import org.springframework.web.bind.annotation.ResponseStatus;import org.springframework.web.bind.annotation.RestControllerAdvice;
/** * Übersetzt Exceptions in Statuscodes – wie das große {@code try/catch} im eigenen Server. Spring * ruft die passende Methode auf, wenn ein Controller eine dieser Exceptions wirft. */@RestControllerAdvicepublic class Fehlerbehandlung {
@ExceptionHandler(MissingRequestHeaderException.class) @ResponseStatus(HttpStatus.FORBIDDEN) public Fehler fehlendesToken(MissingRequestHeaderException e) { return new Fehler("Header " + e.getHeaderName() + " fehlt"); }
@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 konflikt(IllegalStateException e) { return new Fehler(e.getMessage()); }
}Eine Klasse mit @RestControllerAdvice gilt für alle Controller. Wirft ein
Controller eine Exception, sucht Spring die @ExceptionHandler-Methode mit dem
passenden Typ und schickt deren Ergebnis als Antwort – mit dem Statuscode aus
@ResponseStatus. Das ist das große try/catch aus dem Server-Artikel, nur
aufgeteilt in eine Methode pro Fall.
Zwei Exceptions kommen dabei von Spring selbst:
MissingRequestHeaderException– der HeaderX-Spielerfehlt. Daraus wird403, wie im Protokoll vereinbart.HttpMessageNotReadableException– der Rumpf ist kein gültiges JSON:400.
Und eine Sache macht Spring anders als unser Server: Für einen Pfad, den es gar nicht gibt, antwortet es mit seinem Format:
HTTP/1.1 404{"timestamp":"2026-10-23T12:06:20.990Z","status":404,"error":"Not Found","path":"/gibtsnicht"}Unsere Clients stört das nicht – sie fragen keine Pfade ab, die es nicht gibt.
Einstellungen
Abschnitt betitelt „Einstellungen“# Auf diesem Port lauscht der Server – wie bisher 8080server.port=8080# Weniger Meldungen beim Startspring.main.banner-mode=offIn application.properties stehen Einstellungen, für die man im eigenen Server
Code geschrieben hätte – etwa der Port. Spring liest die Datei beim Start vom
Classpath.
Starten
Abschnitt betitelt „Starten“-
Öffne das Projekt in IntelliJ. Beim ersten Mal lädt Maven die Bibliotheken von Spring – das dauert einen Moment.
-
Starte
SchiffeAnwendung. Spring meldet sich mit einigen Zeilen:Terminal-Fenster INFO … de.drv.schiffe.spring.SchiffeAnwendung : Starting SchiffeAnwendung v1.0-SNAPSHOT using Java …INFO … o.s.boot.tomcat.TomcatWebServer : Tomcat initialized with port 8080 (http)INFO … o.s.b.w.a.WelcomePageHandlerMapping : Adding welcome page: class path resource [static/index.html]INFO … o.s.boot.tomcat.TomcatWebServer : Tomcat started on port 8080 (http) with context path '/'INFO … de.drv.schiffe.spring.SchiffeAnwendung : Started SchiffeAnwendung in 0.703 secondsAdding welcome page heißt: Spring hat
static/index.htmlgefunden und liefert sie unter/aus. -
Spiele – genau wie vorher: im Browser unter
http://localhost:8080, mitClientStartundhttp://localhost:8080als Argument, oder gemischt.
Ein JAR, das alles enthält
Abschnitt betitelt „Ein JAR, das alles enthält“Im Kapitel Maven brauchte unser JAR den H2-Treiber
zusätzlich auf dem Classpath. Das spring-boot-maven-plugin packt dagegen
alle Bibliotheken mit hinein. Nach der Phase package:
java -jar target\schiffe-spring-1.0-SNAPSHOT.jarDas JAR ist rund 20 MB groß – Tomcat, Spring und Jackson stecken darin. Dafür braucht es auf einem anderen Rechner nur noch ein JDK. So wird eine Spring-Anwendung üblicherweise ausgeliefert.
Der Beweis: dasselbe Protokoll
Abschnitt betitelt „Der Beweis: dasselbe Protokoll“Im Projekt liegt der HttpSpieldienstTest aus dem Client-Artikel – fast
unverändert. Er startet jetzt den Spring-Server und spielt mit zwei
HttpSpieldiensten ein ganzes Spiel:
@SpringBootTest(classes = SchiffeAnwendung.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)class HttpSpieldienstTest {
@Value("${local.server.port}") // der zufällige Port, auf dem Spring den Server gestartet hat private int port;@SpringBootTeststartet für den Test die ganze Anwendung – mitRANDOM_PORTauf einem freien Port, wie unser Port 0.@Valueholt einen Wert aus den Einstellungen in ein Feld – hier den Port, den Spring gewählt hat. Auch das ist Dependency Injection.
Beide Tests sind grün – das Spiel und die Fehlercodes. Der Java-Client, der für unseren eigenen Server geschrieben wurde, spielt gegen den Spring-Server, ohne dass sich eine Zeile an ihm geändert hat. Denn er kennt nur das Protokoll.
Und Jakarta EE?
Abschnitt betitelt „Und Jakarta EE?“Neben Spring gibt es einen Standard für dasselbe: Jakarta EE, früher Java EE. Dort heißen die Annotationen anders, die Idee ist dieselbe:
| Spring Boot | Jakarta REST (JAX-RS) |
|---|---|
@RestController + @RequestMapping("/spiele") |
@Path("/spiele") |
@PostMapping("/{spielId}/schuesse") |
@POST + @Path("/{spielId}/schuesse") |
@GetMapping, @PutMapping |
@GET, @PUT |
@PathVariable |
@PathParam |
@RequestHeader("X-Spieler") |
@HeaderParam("X-Spieler") |
@RequestBody |
ein Parameter ohne Annotation |
@ExceptionHandler |
ein ExceptionMapper |
Ein Jakarta-Programm läuft in einem Anwendungsserver wie WildFly, Payara oder
Open Liberty – oder, ähnlich wie Spring Boot, mit einem eingebauten Server, etwa
mit Quarkus oder Helidon. Es ist dasselbe Muster wie bei JDBC und dem
HttpServer: Jakarta EE ist eine Spezifikation, die Anwendungsserver sind
ihre Implementierungen.
Zum Ausprobieren
Abschnitt betitelt „Zum Ausprobieren“- Die Attrappe: Ändere die
@Bean-Methode so, dass sie einenAttrappenSpieldienstliefert. Was merken die Clients? - Ein anderer Port: Setze in
application.propertiesserver.port=9090und starte neu. Was müssen die Clients jetzt anders machen? - Ein neuer Endpunkt:
GET /spielesoll zählen, wie viele Spiele es gibt. Was muss dafür imSpieldienstdazukommen – und wer muss es alles umsetzen? - Vergleichen: Lege
SpielServeraus dem Server-Artikel undSpielControllernebeneinander. Welche Zeilen gibt es in beiden?