Zum Inhalt springen

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.

  • erklären, was ein Framework ist und was Spring Boot einem abnimmt
  • einen @RestController lesen: 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 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 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.

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.

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>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-webmvc bringt 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-plugin baut 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, Fehlerbehandlung
src/main/resources
├── application.properties Einstellungen
└── static/ die Webseite aus dem letzten Artikel, unverändert
SchiffeAnwendung.java
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.
*/
@SpringBootApplication
public 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();
}
}
  • @SpringBootApplication sagt: Hier beginnt eine Spring-Anwendung. Spring durchsucht das Package dieser Klasse – und alle darunter – nach Klassen mit Annotationen wie @RestController.
  • @Bean an einer Methode heißt: Spring ruft sie einmal auf und merkt sich das Objekt. Wer einen Spieldienst braucht, bekommt genau dieses.

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:

SpielController.java (Ausschnitt)
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.

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

Fehlerbehandlung.java
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.
*/
@RestControllerAdvice
public 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 Header X-Spieler fehlt. Daraus wird 403, 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:

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

application.properties
# Auf diesem Port lauscht der Server – wie bisher 8080
server.port=8080
# Weniger Meldungen beim Start
spring.main.banner-mode=off

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

  1. Öffne das Projekt in IntelliJ. Beim ersten Mal lädt Maven die Bibliotheken von Spring – das dauert einen Moment.

  2. 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 seconds

    Adding welcome page heißt: Spring hat static/index.html gefunden und liefert sie unter / aus.

  3. Spiele – genau wie vorher: im Browser unter http://localhost:8080, mit ClientStart und http://localhost:8080 als Argument, oder gemischt.

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:

PowerShell
java -jar target\schiffe-spring-1.0-SNAPSHOT.jar

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

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:

HttpSpieldienstTest.java (Ausschnitt)
@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;
  • @SpringBootTest startet für den Test die ganze Anwendung – mit RANDOM_PORT auf einem freien Port, wie unser Port 0.
  • @Value holt 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.

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.

  • Die Attrappe: Ändere die @Bean-Methode so, dass sie einen AttrappenSpieldienst liefert. Was merken die Clients?
  • Ein anderer Port: Setze in application.properties server.port=9090 und starte neu. Was müssen die Clients jetzt anders machen?
  • Ein neuer Endpunkt: GET /spiele soll zählen, wie viele Spiele es gibt. Was muss dafür im Spieldienst dazukommen – und wer muss es alles umsetzen?
  • Vergleichen: Lege SpielServer aus dem Server-Artikel und SpielController nebeneinander. Welche Zeilen gibt es in beiden?