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.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- Spieler über ein Token erkennen und ihnen nur zeigen, was sie wissen dürfen
- erklären, warum der Spieldienst
synchronizedsein muss – und es mit einem Test zeigen - Server und Clients auf verschiedenen Rechnern starten und verbinden
- typische Fehler beim Verbinden erkennen und beheben
Teil 1: Der Spieldienst
Abschnitt betitelt „Teil 1: Der Spieldienst“Demo-Code: 37-schiffe-dienst
⤓ schiffe-dienst.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 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.
Was der Dienst tut
Abschnitt betitelt „Was der Dienst tut“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:
/** 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.
Die Sicht eines Spielers
Abschnitt betitelt „Die Sicht eines Spielers“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.
Warum synchronized?
Abschnitt betitelt „Warum synchronized?“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.
Die Tests
Abschnitt betitelt „Die Tests“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.
Übung: Der Spieldienst
Abschnitt betitelt „Übung: Der Spieldienst“Fülle LokalerSpieldienst aus, bis alle Tests grün sind.
- Spiele und Tokens:
neuesSpielundbeitretenlegen einSpielan bzw. treten bei und vergeben Tokens. Eine Hilfsmethodeseite(spielId, token)findet die Seite zu einem Token – oder wirftSpielNichtGefunden. - Aufstellen und Sicht:
aufstellenmacht aus jederAufstellungeinSchiff, daraus eineFlotte, und übergibt sie dem Spiel.standbaut denSpielstandaus der Sicht des Fragenden. - Schießen und Gleichzeitigkeit:
schiessenreicht den Schuss an das Spiel weiter. Und alle öffentlichen Methoden werdensynchronized. - Für Schnelle: Entferne zur Probe das
synchronizedund lass den letzten Test mehrmals laufen. Welche Exception kommt – und warum ausgerechnet diese?
Lösung
Platzist ein privater Record im Dienst – niemand außerhalb braucht ihn.seiteprüft zuerst, ob es das Spiel gibt, dann, ob das Token dazugehört.gewonnenvergleicht den Gewinner mit der eigenen Seite – erst, wenn das Spiel vorbei ist. Vorher bleibt esnull.Map.copyOfgibt die Schüsse als Kopie heraus: Was danach im Spiel passiert, ändert einen schon geliefertenSpielstandnicht 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.
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; }
}Teil 2: Zusammenspielen
Abschnitt betitelt „Teil 2: Zusammenspielen“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 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 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
Zuerst auf einem Rechner
Abschnitt betitelt „Zuerst auf einem Rechner“-
Starte
ServerStart– ohne Argument, also mit dem echten Spieldienst. -
Starte
ClientStartmit dem Argumenthttp://localhost:8080und lege mitnein neues Spiel an. Der Client zeigt die Spiel-ID und wartet. -
Starte
ClientStartein zweites Mal, mit demselben Argument, und tritt mitbund der Spiel-ID bei. -
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:
(n)eues Spiel oder (b)eitreten? nSpiel angelegt. Gib deinem Gegner die ID: ef5cbc6d-2350-449b-84ab-9d2e0de8a2bcWarte auf den Gegner …Stelle deine Flotte auf: Anfangsfeld und Richtung, z. B. B2 W (waagerecht) oder B2 S (senkrecht).…Dein Schuss: B9B9: VERSENKTGewonnen!Ben tritt bei:
(n)eues Spiel oder (b)eitreten? bSpiel-ID: ef5cbc6d-2350-449b-84ab-9d2e0de8a2bcStelle deine Flotte auf: …Aufgestellt.Der Gegner ist dran ……Verloren.Und der Server protokolliert jede Anfrage:
Spiel-Server auf http://localhost:8080POST /spiele 201 36 msGET /spiele/ef5cbc6d-… 200 4 msGET /spiele/ef5cbc6d-… 200 1 msPOST /spiele/ef5cbc6d-…/spieler 201 0 msPUT /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.
Dann Rechner gegen Rechner
Abschnitt betitelt „Dann Rechner gegen Rechner“-
Wer ist der Server? Einer startet
ServerStart. Seine Adresse findet er im Terminal:PowerShell ipconfigTerminal-Fenster Ethernet-Adapter Ethernet:…IPv4-Adresse . . . . . . . . . . : 192.168.1.23 -
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.
-
Verbindung prüfen – noch ohne Client. Auf einem anderen Rechner:
PowerShell curl.exe -i -X POST http://192.168.1.23:8080/spieleKommt
201 Created, steht die Verbindung. -
Spielen. Beide starten
ClientStartmithttp://192.168.1.23:8080.
Wenn es nicht klappt
Abschnitt betitelt „Wenn es nicht klappt“| 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 |
Übung: Spielen
Abschnitt betitelt „Übung: Spielen“- Spielt ein Spiel auf einem Rechner – Server und zwei Clients.
- Spielt Rechner gegen Rechner.
- 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?
- 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.exeabsichtlich Unsinn schickt?