Zum Inhalt springen

Schiffe versenken: Spieldienst und Zusammenspiel

Es fehlt noch ein Stück zwischen Server und Kern: der LokalerSpieldienst. Er führt die Spiele wirklich – bisher sprang dafür eine Attrappe ein. Ist er fertig, passt alles zusammen: Kern, Dienst, Server, Client. Und dann wird gespielt, Rechner gegen Rechner.

  • Spieler über ein Token erkennen und ihnen nur zeigen, was sie wissen dürfen
  • erklären, warum der Spieldienst synchronized sein muss – und es mit einem Test zeigen
  • Server und Clients auf verschiedenen Rechnern starten und verbinden
  • typische Fehler beim Verbinden erkennen und beheben

Demo-Code: 37-schiffe-dienst

⤓ schiffe-dienst.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 37-schiffe-dienst 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, Aufstellung.java, Beitritt.java, LokalerSpieldienst.java, SpielNichtGefunden.java, Spieldienst.java, Spielstand.java, Ergebnis.java, Flotte.java, Koordinate.java, Phase.java, Richtung.java, Schiff.java, Schiffstyp.java, Seite.java, Spiel.java, LokalerSpieldienstTest.java

Das Demo-Projekt enthält den fertigen Kern aus dem Kern-Artikel, das Package dienst mit dem Gerüst des LokalerSpieldienst – und eine vorgegebene Testklasse.

Der Spieldienst ist der Vertrag aus dem Klassenmodell. Der LokalerSpieldienst erfüllt ihn mit dem echten Kern – und hat dabei drei Aufgaben, die das Spiel nicht kennt:

Aufgabe das Spiel kennt … der Dienst übersetzt in …
Spiele verwalten nur sich selbst eine Map von Spiel-ID zu Spiel
Spieler erkennen nur Seite.EINS und Seite.ZWEI Tokens: Wem gehört dieses Token, in welchem Spiel?
Sicht eines Spielers alle Schüsse beider Seiten einen Spielstand aus der Sicht dessen, der fragt

Beim Anlegen und Beitreten bekommt jeder Spieler ein Token: eine zufällige, nicht zu erratende Kennung, etwa mit UUID.randomUUID(). Der Dienst merkt sich, wem es gehört:

LokalerSpieldienst.java (Ausschnitt)
/** Wem ein Token gehört: welchem Spiel, welcher Seite. */
private record Platz(String spielId, Seite seite) {
}
private final Map<String, Spiel> spiele = new HashMap<>();
private final Map<String, Platz> plaetze = new HashMap<>();

Bei jedem Aufruf mit Token fragt er zuerst: Gibt es das Token – und gehört es zu diesem Spiel? Sonst könnte Clara mit ihrem Token aus einem anderen Spiel in Annas Spiel schießen. Ein falsches Token wird zu SpielNichtGefunden – und beim Server zu 404.

Der Spielstand wird für jeden Aufruf neu gebaut – aus der Sicht der Seite, der das Token gehört:

Feld des Spielstand für Seite s
phase die Phase des Spiels
amZug ob s gerade dran ist
eigeneSchuesse spiel.schuesseVon(s)
gegnerischeSchuesse spiel.schuesseVon(s.gegner())
gewonnen null, solange es läuft – danach, ob s der Gewinner ist

Die Schiffe des Gegners stehen nirgends darin. Was nicht im Spielstand steht, kann kein Client erfahren – egal, wie geschickt er fragt.

Der Server bearbeitet jede Anfrage in einem eigenen Thread. Fragt Anna nach dem Stand, während Ben schießt, sind zwei Threads gleichzeitig im Dienst – und in seinen HashMaps. Eine HashMap verträgt das nicht: Einträge gehen verloren oder landen an der falschen Stelle, wie die Wörter im Kapitel Parallelität.

Mit synchronized an jeder öffentlichen Methode ist immer nur ein Thread im Dienst. Das ist die einfachste Lösung – und für ein Spiel mit ein paar Spielern schnell genug.

LokalerSpieldienstTest.java
LokalerSpieldienstTest.java
package de.drv.schiffe.dienst;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import de.drv.schiffe.spiel.Ergebnis;
import de.drv.schiffe.spiel.Koordinate;
import de.drv.schiffe.spiel.Phase;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
class LokalerSpieldienstTest {
/** Alle fünf Schiffe waagerecht ab Spalte A, in den Zeilen 1, 3, 5, 7 und 9. */
static final List<Aufstellung> FLOTTE = List.of(
Aufstellung.von("FLUGZEUGTRAEGER A1 W"), Aufstellung.von("SCHLACHTSCHIFF A3 W"),
Aufstellung.von("KREUZER A5 W"), Aufstellung.von("U_BOOT A7 W"), Aufstellung.von("ZERSTOERER A9 W"));
private final LokalerSpieldienst dienst = new LokalerSpieldienst();
// ----- Stufe 1: Spiele und Tokens ----------------------------------------------------
@Test
@DisplayName("Stufe 1: Anlegen und Beitreten liefern dieselbe Spiel-ID, aber verschiedene Tokens")
void anlegenUndBeitreten() {
Beitritt anna = dienst.neuesSpiel();
Beitritt ben = dienst.beitreten(anna.spielId());
assertEquals(anna.spielId(), ben.spielId());
assertNotEquals(anna.token(), ben.token());
assertNotEquals(anna.spielId(), dienst.neuesSpiel().spielId());
}
@Test
@DisplayName("Stufe 1: Ein unbekanntes Spiel gibt es nicht – und ein drittes Mal beitreten geht nicht")
void beitretenFehler() {
assertThrows(SpielNichtGefunden.class, () -> dienst.beitreten("gibt-es-nicht"));
Beitritt anna = dienst.neuesSpiel();
dienst.beitreten(anna.spielId());
assertThrows(IllegalStateException.class, () -> dienst.beitreten(anna.spielId()));
}
@Test
@DisplayName("Stufe 1: Ein falsches Token – oder eines aus einem anderen Spiel – wird abgelehnt")
void fremdesToken() {
Beitritt anna = dienst.neuesSpiel();
Beitritt clara = dienst.neuesSpiel();
assertThrows(SpielNichtGefunden.class, () -> dienst.stand(anna.spielId(), "falsch"));
assertThrows(SpielNichtGefunden.class, () -> dienst.stand(anna.spielId(), clara.token()));
assertThrows(SpielNichtGefunden.class, () -> dienst.stand("gibt-es-nicht", anna.token()));
}
// ----- Stufe 2: Aufstellen und die eigene Sicht --------------------------------------
@Test
@DisplayName("Stufe 2: Der Stand zeigt die Phase – erst warten, dann aufstellen, dann läuft es")
void phasen() {
Beitritt anna = dienst.neuesSpiel();
assertEquals(Phase.WARTEN_AUF_GEGNER, dienst.stand(anna.spielId(), anna.token()).phase());
Beitritt ben = dienst.beitreten(anna.spielId());
assertEquals(Phase.AUFSTELLEN, dienst.stand(anna.spielId(), anna.token()).phase());
dienst.aufstellen(anna.spielId(), anna.token(), FLOTTE);
dienst.aufstellen(ben.spielId(), ben.token(), FLOTTE);
Spielstand annasSicht = dienst.stand(anna.spielId(), anna.token());
Spielstand bensSicht = dienst.stand(ben.spielId(), ben.token());
assertEquals(Phase.LAEUFT, annasSicht.phase());
assertTrue(annasSicht.amZug()); // Spieler 1 beginnt
assertFalse(bensSicht.amZug());
assertNull(annasSicht.gewonnen());
}
@Test
@DisplayName("Stufe 2: Eine ungültige Aufstellung wird abgelehnt")
void ungueltigeAufstellung() {
Beitritt anna = dienst.neuesSpiel();
dienst.beitreten(anna.spielId());
assertThrows(IllegalArgumentException.class,
() -> dienst.aufstellen(anna.spielId(), anna.token(), FLOTTE.subList(0, 4)));
List<Aufstellung> ueberDenRand = new ArrayList<>(FLOTTE);
ueberDenRand.set(0, Aufstellung.von("FLUGZEUGTRAEGER G1 W"));
assertThrows(IllegalArgumentException.class,
() -> dienst.aufstellen(anna.spielId(), anna.token(), ueberDenRand));
}
@Test
@DisplayName("Stufe 2: Jeder sieht seine Schüsse und die des Gegners auf ihn – sonst nichts")
void sicht() {
Beitritt anna = dienst.neuesSpiel();
Beitritt ben = dienst.beitreten(anna.spielId());
dienst.aufstellen(anna.spielId(), anna.token(), FLOTTE);
dienst.aufstellen(ben.spielId(), ben.token(), FLOTTE);
assertEquals(Ergebnis.TREFFER, dienst.schiessen(anna.spielId(), anna.token(), Koordinate.von("A1")));
assertEquals(Ergebnis.WASSER, dienst.schiessen(ben.spielId(), ben.token(), Koordinate.von("J10")));
Spielstand annasSicht = dienst.stand(anna.spielId(), anna.token());
assertEquals(Map.of(Koordinate.von("A1"), Ergebnis.TREFFER), annasSicht.eigeneSchuesse());
assertEquals(Map.of(Koordinate.von("J10"), Ergebnis.WASSER), annasSicht.gegnerischeSchuesse());
Spielstand bensSicht = dienst.stand(ben.spielId(), ben.token());
assertEquals(annasSicht.eigeneSchuesse(), bensSicht.gegnerischeSchuesse());
}
// ----- Stufe 3: ein ganzes Spiel und gleichzeitige Zugriffe --------------------------
@Test
@DisplayName("Stufe 3: Ein ganzes Spiel – wer gewinnt, sieht gewonnen = true, der andere false")
void ganzesSpiel() {
Beitritt anna = dienst.neuesSpiel();
Beitritt ben = dienst.beitreten(anna.spielId());
dienst.aufstellen(anna.spielId(), anna.token(), FLOTTE);
dienst.aufstellen(ben.spielId(), ben.token(), FLOTTE);
List<Koordinate> bensSchiffe = new ArrayList<>();
for (Aufstellung schiff : FLOTTE) {
for (int i = 0; i < schiff.typ().getLaenge(); i++) {
bensSchiffe.add(schiff.anfang().verschoben(schiff.richtung(), i));
}
}
for (int i = 0; i < bensSchiffe.size(); i++) {
dienst.schiessen(anna.spielId(), anna.token(), bensSchiffe.get(i));
if (i < bensSchiffe.size() - 1) {
dienst.schiessen(ben.spielId(), ben.token(), new Koordinate(i % 10, 1 + 2 * (i / 10)));
}
}
assertEquals(Phase.VORBEI, dienst.stand(anna.spielId(), anna.token()).phase());
assertTrue(dienst.stand(anna.spielId(), anna.token()).gewonnen());
assertFalse(dienst.stand(ben.spielId(), ben.token()).gewonnen());
}
@Test
@DisplayName("Stufe 3: Viele gleichzeitige Spiele gehen nicht durcheinander")
void gleichzeitig() throws Exception {
List<Future<Beitritt>> ergebnisse = new ArrayList<>();
try (ExecutorService pool = Executors.newFixedThreadPool(8)) {
for (int i = 0; i < 2000; i++) {
ergebnisse.add(pool.submit(dienst::neuesSpiel));
}
}
for (Future<Beitritt> ergebnis : ergebnisse) {
Beitritt beitritt = ergebnis.get();
assertEquals(Phase.WARTEN_AUF_GEGNER, dienst.stand(beitritt.spielId(), beitritt.token()).phase());
}
}
}

Der letzte Test legt mit acht Threads gleichzeitig 2000 Spiele an und prüft dann, ob jedes noch zu finden ist. Ohne synchronized schlägt er fast immer fehl – mit ihm nie. Ein Test für gleichzeitige Zugriffe kann allerdings nur zeigen, dass etwas kaputt ist, nie beweisen, dass es heil ist: Ein Fehler, der nur jedes tausendste Mal auftritt, rutscht womöglich durch.

Fülle LokalerSpieldienst aus, bis alle Tests grün sind.

  1. Spiele und Tokens: neuesSpiel und beitreten legen ein Spiel an bzw. treten bei und vergeben Tokens. Eine Hilfsmethode seite(spielId, token) findet die Seite zu einem Token – oder wirft SpielNichtGefunden.
  2. Aufstellen und Sicht: aufstellen macht aus jeder Aufstellung ein Schiff, daraus eine Flotte, und übergibt sie dem Spiel. stand baut den Spielstand aus der Sicht des Fragenden.
  3. Schießen und Gleichzeitigkeit: schiessen reicht den Schuss an das Spiel weiter. Und alle öffentlichen Methoden werden synchronized.
  4. Für Schnelle: Entferne zur Probe das synchronized und lass den letzten Test mehrmals laufen. Welche Exception kommt – und warum ausgerechnet diese?
Lösung
  • Platz ist ein privater Record im Dienst – niemand außerhalb braucht ihn.
  • seite prüft zuerst, ob es das Spiel gibt, dann, ob das Token dazugehört.
  • gewonnen vergleicht den Gewinner mit der eigenen Seite – erst, wenn das Spiel vorbei ist. Vorher bleibt es null.
  • Map.copyOf gibt die Schüsse als Kopie heraus: Was danach im Spiel passiert, ändert einen schon gelieferten Spielstand nicht mehr.

Zu Stufe 4: Ohne synchronized meldet der Test SpielNichtGefunden – mal mit Kein Spiel mit der ID …, mal mit Dieses Token gehört nicht zum Spiel …. Zwei Threads haben gleichzeitig in eine der beiden HashMaps geschrieben, und ein Eintrag ist verloren gegangen: einmal der des Spiels, einmal der des Tokens. Das Spiel wurde angelegt – aber es ist nicht mehr zu finden.

LokalerSpieldienst.java
package de.drv.schiffe.dienst;
import de.drv.schiffe.spiel.Ergebnis;
import de.drv.schiffe.spiel.Flotte;
import de.drv.schiffe.spiel.Koordinate;
import de.drv.schiffe.spiel.Phase;
import de.drv.schiffe.spiel.Schiff;
import de.drv.schiffe.spiel.Seite;
import de.drv.schiffe.spiel.Spiel;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Führt die Spiele im selben Programm: eine Map von Spiel-ID zu {@code Spiel} und eine von Token
* zu Seite. Er übersetzt die Aufrufe des Vertrags in Aufrufe des Kerns.
*
* <p>Der Server benutzt ihn für alle Spieler zugleich – deshalb sind die Methoden
* {@code synchronized}.
*/
public class LokalerSpieldienst implements Spieldienst {
/** Wem ein Token gehört: welchem Spiel, welcher Seite. */
private record Platz(String spielId, Seite seite) {
}
private final Map<String, Spiel> spiele = new HashMap<>();
private final Map<String, Platz> plaetze = new HashMap<>();
@Override
public synchronized Beitritt neuesSpiel() {
String spielId = UUID.randomUUID().toString();
spiele.put(spielId, new Spiel());
return new Beitritt(spielId, vergebeToken(spielId, Seite.EINS));
}
@Override
public synchronized Beitritt beitreten(String spielId) {
spiel(spielId).gegnerTrittBei(); // wirft, wenn schon zwei da sind
return new Beitritt(spielId, vergebeToken(spielId, Seite.ZWEI));
}
@Override
public synchronized void aufstellen(String spielId, String token, List<Aufstellung> flotte) {
Seite seite = seite(spielId, token);
List<Schiff> schiffe = new ArrayList<>();
for (Aufstellung aufstellung : flotte) {
schiffe.add(new Schiff(aufstellung.typ(), aufstellung.anfang(), aufstellung.richtung()));
}
spiel(spielId).stelleAuf(seite, new Flotte(schiffe));
}
@Override
public synchronized Spielstand stand(String spielId, String token) {
Seite seite = seite(spielId, token);
Spiel spiel = spiel(spielId);
Boolean gewonnen = spiel.getPhase() == Phase.VORBEI
? spiel.gewinner().orElseThrow() == seite
: null;
return new Spielstand(spiel.getPhase(),
spiel.amZug().map(amZug -> amZug == seite).orElse(false),
Map.copyOf(spiel.schuesseVon(seite)),
Map.copyOf(spiel.schuesseVon(seite.gegner())),
gewonnen);
}
@Override
public synchronized Ergebnis schiessen(String spielId, String token, Koordinate ziel) {
return spiel(spielId).schiesse(seite(spielId, token), ziel);
}
private Spiel spiel(String spielId) {
Spiel spiel = spiele.get(spielId);
if (spiel == null) {
throw new SpielNichtGefunden("Kein Spiel mit der ID " + spielId);
}
return spiel;
}
/** Die Seite, der das Token gehört – nur, wenn es auch zu diesem Spiel gehört. */
private Seite seite(String spielId, String token) {
spiel(spielId);
Platz platz = plaetze.get(token);
if (platz == null || !platz.spielId().equals(spielId)) {
throw new SpielNichtGefunden("Dieses Token gehört nicht zum Spiel " + spielId);
}
return platz.seite();
}
private String vergebeToken(String spielId, Seite seite) {
String token = UUID.randomUUID().toString();
plaetze.put(token, new Platz(spielId, seite));
return token;
}
}

Jetzt kommen alle Teile zusammen. Wer Kern, Dienst, Server und Client selbst gebaut hat, steckt sie in ein Projekt. Wer ein Stück nicht fertig hat, nimmt das vollständige Spiel:

Demo-Code: 38-schiffe-komplett

⤓ schiffe-komplett.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 38-schiffe-komplett 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, FehlendesToken.java, ServerStart.java, SpielServer.java, Ergebnis.java, Flotte.java, Koordinate.java, Phase.java, Richtung.java, Schiff.java, Schiffstyp.java, Seite.java, Spiel.java, HttpSpieldienstTest.java, KonsoleTest.java, SpielServerTest.java, FlotteTest.java, KoordinateTest.java, SpielTest.java

  1. Starte ServerStart – ohne Argument, also mit dem echten Spieldienst.

  2. Starte ClientStart mit dem Argument http://localhost:8080 und lege mit n ein neues Spiel an. Der Client zeigt die Spiel-ID und wartet.

  3. Starte ClientStart ein zweites Mal, mit demselben Argument, und tritt mit b und der Spiel-ID bei.

  4. Stellt beide Flotten auf und spielt – im Wechsel zwischen den beiden Reitern.

So sah ein Spiel aus, bei dem beide Clients ihre Eingaben aus einer Datei bekamen. Anna legt an:

Terminal-Fenster
(n)eues Spiel oder (b)eitreten? n
Spiel angelegt. Gib deinem Gegner die ID: ef5cbc6d-2350-449b-84ab-9d2e0de8a2bc
Warte auf den Gegner …
Stelle deine Flotte auf: Anfangsfeld und Richtung, z. B. B2 W (waagerecht) oder B2 S (senkrecht).
…
Dein Schuss: B9
B9: VERSENKT
Gewonnen!

Ben tritt bei:

Terminal-Fenster
(n)eues Spiel oder (b)eitreten? b
Spiel-ID: ef5cbc6d-2350-449b-84ab-9d2e0de8a2bc
Stelle deine Flotte auf: …
Aufgestellt.
Der Gegner ist dran …
…
Verloren.

Und der Server protokolliert jede Anfrage:

Terminal-Fenster
Spiel-Server auf http://localhost:8080
POST /spiele 201 36 ms
GET /spiele/ef5cbc6d-… 200 4 ms
GET /spiele/ef5cbc6d-… 200 1 ms
POST /spiele/ef5cbc6d-…/spieler 201 0 ms
PUT /spiele/ef5cbc6d-…/flotte 204 22 ms
…

Das ganze Spiel dauerte 30 Sekunden – und der Server beantwortete dabei 95 GET-Anfragen: Das ist das Polling. Jeder Client fragt einmal pro Sekunde, ob er dran ist.

  1. Wer ist der Server? Einer startet ServerStart. Seine Adresse findet er im Terminal:

    PowerShell
    ipconfig
    Terminal-Fenster
    Ethernet-Adapter Ethernet:
    …
    IPv4-Adresse . . . . . . . . . . : 192.168.1.23
  2. Die Firewall. Beim ersten Start fragt Windows, ob Java im Netzwerk kommunizieren darf – mit Zugriff zulassen bestätigen. Kam die Frage nicht oder wurde sie abgelehnt, blockiert die Firewall Verbindungen von außen.

  3. Verbindung prüfen – noch ohne Client. Auf einem anderen Rechner:

    PowerShell
    curl.exe -i -X POST http://192.168.1.23:8080/spiele

    Kommt 201 Created, steht die Verbindung.

  4. Spielen. Beide starten ClientStart mit http://192.168.1.23:8080.

Was passiert wahrscheinliche Ursache was hilft
Connection refused – sofort Server läuft nicht, falscher Port, oder ein anderes Programm hält Port 8080 Server starten; Port in Adresse und ServerStart vergleichen
Lange nichts, dann connect timed out falsche IP-Adresse oder die Firewall blockiert ipconfig noch einmal; curl.exe vom eigenen Rechner mit der IP-Adresse statt localhost – klappt es dort, ist es die Firewall
Address already in use beim Start des Servers ein Server läuft schon – oft der von vorhin im Fenster Run das rote Quadrat drücken
404 beim Beitreten Spiel-ID falsch abgetippt – oder der Server wurde neu gestartet Der Server merkt sich die Spiele nur, solange er läuft. Nach einem Neustart neues Spiel anlegen
404 mitten im Spiel Token und Spiel passen nicht zusammen Beim Client: Wird das Token aus dem Beitritt benutzt?
403 der Header X-Spieler fehlt Beim Client: Wird das Token mitgeschickt?
409 Du bist nicht dran der Client schießt, ohne zu warten Beim Client: vor dem Schuss warteBis(… amZug …)
500 ein Fehler im Server Stacktrace in der Konsole des Servers lesen
  1. Spielt ein Spiel auf einem Rechner – Server und zwei Clients.
  2. Spielt Rechner gegen Rechner.
  3. Wer Server und Client selbst gebaut hat: Spielt euren Client gegen den Server einer anderen Gruppe – und umgekehrt. Hält sich jeder an das Protokoll?
  4. Für Schnelle: Startet einen Server und lasst mehrere Paare gleichzeitig darauf spielen. Wie viele Spiele hält er aus? Und was steht im Protokoll des Servers, wenn ihr mit curl.exe absichtlich Unsinn schickt?