Schiffe versenken: Ein Klassenmodell
Im ersten Artikel haben wir das Spiel und seine Tücken beschrieben und ein Protokoll entworfen. Hier geht es um die Frage: Wie teilt man das Programm auf? Welche Klassen gibt es, welche Interfaces, und in welche Packages gehören sie?
Was folgt, ist ein möglicher Entwurf – kein Muss. Er ist so gebaut, dass mehrere Leute gleichzeitig daran arbeiten können, ohne sich in die Quere zu kommen.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- ein größeres Programm in Packages mit klaren Aufgaben aufteilen
- erklären, welches Package von welchem abhängen darf – und warum nicht umgekehrt
- an einem Interface erkennen, wo Client und Server sich treffen
- den Unterschied zwischen einem fachlichen Typ und einer Nachricht im Protokoll erklären
Demo-Code: 33-schiffe-modell
⤓ schiffe-modell.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 33-schiffe-modell 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, ClientStart.java, Feldanzeige.java, HttpSpieldienst.java, Konsole.java, Aufstellung.java, Beitritt.java, LokalerSpieldienst.java, SpielNichtGefunden.java, Spieldienst.java, Spielstand.java, Nachrichten.java, Protokoll.java, ServerStart.java, SpielServer.java, Ergebnis.java, Flotte.java, Koordinate.java, Phase.java, Richtung.java, Schiff.java, Schiffstyp.java, Seite.java, Spiel.java, KoordinateTest.java
Das Gerüst lässt sich übersetzen. Alle Typen und Verträge stehen fest, die
Methoden der großen Klassen werfen noch eine UnsupportedOperationException.
Fertig ausgearbeitet sind nur Koordinate und Schiffstyp – als Beispiele.
Fünf Packages
Abschnitt betitelt „Fünf Packages“Ordnersrc/main/java/de/drv/schiffe
Ordnerspiel der Kern: Regeln des Spiels, kein Netz
- Koordinate.java
- Richtung.java
- Schiffstyp.java
- Ergebnis.java
- Phase.java
- Seite.java
- Schiff.java
- Flotte.java
- Spiel.java
Ordnerdienst der Vertrag: was ein Spieler tun kann
- Spieldienst.java Interface
- Beitritt.java
- Aufstellung.java
- Spielstand.java
- SpielNichtGefunden.java
- LokalerSpieldienst.java
Ordnerprotokoll was über die Leitung geht
- Protokoll.java
- Nachrichten.java
Ordnerserver HTTP auf der Server-Seite
- SpielServer.java
- ServerStart.java
Ordnerclient HTTP und Konsole auf der Spieler-Seite
- HttpSpieldienst.java
- Feldanzeige.java
- Konsole.java
- ClientStart.java
| Package | Aufgabe | weiß nichts von |
|---|---|---|
spiel |
die Regeln: Aufstellen, Schießen, Phasen, Gewinner | Netz, Tokens, JSON, Konsole |
dienst |
der Vertrag Spieldienst – und eine Umsetzung, die Spiele im selben Programm führt |
HTTP, Konsole |
protokoll |
Pfade, Header und die Formen der Nachrichten | allem anderen |
server |
übersetzt HTTP-Anfragen in Aufrufe des Dienstes | der Konsole |
client |
Konsole und eine Umsetzung des Dienstes, die über HTTP spricht | wie der Server innen aussieht |
Wer darf wen kennen?
Abschnitt betitelt „Wer darf wen kennen?“ client server │ ╲ ╱ │ │ ▼ ▼ │ │ protokoll │ kennt niemanden │ │ └──────▶ dienst ◀──────┘ │ ▼ spiel kennt niemanden – alle dürfen es benutzenDie Pfeile zeigen nur in eine Richtung: client und server benutzen
protokoll und dienst, der dienst benutzt das spiel. Nie umgekehrt. Das
spiel hat keine einzige Zeile, die etwas über HTTP weiß – und client und
server kennen einander gar nicht. Sie haben nur das Protokoll gemeinsam.
Warum ist das so wichtig?
- Das
spiellässt sich allein testen – mit JUnit, ohne Server. - Wer am Server arbeitet, kann am Kern nichts kaputt machen, was nicht auch ein Test bemerkt.
- Soll das Spiel später im Browser laufen oder mit Spring Boot, bleibt der Kern
unverändert. Nur
serverwird ersetzt.
Eine einfache Probe: Steht in einer Klasse aus spiel ein import aus
dienst, server oder client, ist der Entwurf verletzt.
Der Kern: spiel
Abschnitt betitelt „Der Kern: spiel“Kleine Typen, die sich selbst prüfen
Abschnitt betitelt „Kleine Typen, die sich selbst prüfen“package de.drv.schiffe.spiel;
/** * Ein Kästchen auf dem Feld, z. B. B7. Intern zählen Spalte und Zeile ab 0: * A1 ist (0, 0), J10 ist (9, 9). * * <p>Der kompakte Konstruktor prüft den Bereich – eine ungültige Koordinate kann es nicht geben. */public record Koordinate(int spalte, int zeile) {
public static final int GROESSE = 10;
public Koordinate { if (spalte < 0 || spalte >= GROESSE || zeile < 0 || zeile >= GROESSE) { throw new IllegalArgumentException("Außerhalb des Felds: Spalte " + spalte + ", Zeile " + zeile); } }
/** Liest eine Koordinate wie "B7" oder "j10" – Groß- und Kleinschreibung egal. */ public static Koordinate von(String text) { if (text == null || !text.trim().matches("(?i)[A-J]([1-9]|10)")) { throw new IllegalArgumentException("Keine Koordinate: " + text); } String sauber = text.trim().toUpperCase(); return new Koordinate(sauber.charAt(0) - 'A', Integer.parseInt(sauber.substring(1)) - 1); }
/** Die Koordinate, die {@code schritte} Kästchen weiter in einer Richtung liegt. */ public Koordinate verschoben(Richtung richtung, int schritte) { return richtung == Richtung.WAAGERECHT ? new Koordinate(spalte + schritte, zeile) : new Koordinate(spalte, zeile + schritte); }
/** Als Text, wie Menschen sie schreiben: "B7". */ @Override public String toString() { return "" + (char) ('A' + spalte) + (zeile + 1); }
}Die Koordinate ist ein Record mit einem kompakten Konstruktor, der den
Bereich prüft. Eine Koordinate K11 kann es deshalb gar nicht geben – jede
Methode, die eine Koordinate bekommt, muss das nicht mehr selbst prüfen. Die
statische Methode von("B7") liest den Text, den ein Mensch tippt – mit dem
regulären Ausdruck [A-J]([1-9]|10).
package de.drv.schiffe.spiel;
/** Die fünf Schiffe einer Flotte – jedes Enum-Objekt kennt seine Länge. */public enum Schiffstyp {
FLUGZEUGTRAEGER(5), SCHLACHTSCHIFF(4), KREUZER(3), U_BOOT(3), ZERSTOERER(2);
private final int laenge;
Schiffstyp(int laenge) { this.laenge = laenge; }
public int getLaenge() { return laenge; }
}Ein Enum mit einem Feld: Jedes Schiff kennt seine Länge. Wer wissen will, wie
viele Kästchen eine ganze Flotte belegt, läuft über Schiffstyp.values().
Dazu die kleinen Enums Richtung (waagerecht, senkrecht), Ergebnis (Wasser,
Treffer, versenkt), Phase (warten auf Gegner, aufstellen, läuft, vorbei) und
Seite (eins, zwei) – mit gegner(), das die jeweils andere Seite liefert.
Die drei Klassen mit Zustand
Abschnitt betitelt „Die drei Klassen mit Zustand“| Klasse | kennt | kann |
|---|---|---|
Schiff |
Typ, Kästchen, Treffer | sagen, ob es ein Kästchen belegt; einen Treffer vermerken; sagen, ob es versenkt ist |
Flotte |
die fünf Schiffe, die Schüsse darauf | beim Aufstellen alle Regeln prüfen; einen Schuss beantworten; sagen, ob alles versenkt ist |
Spiel |
Phase, beide Flotten, wer dran ist, alle Schüsse | Beitritt, Aufstellen, Schießen in der richtigen Reihenfolge erzwingen |
package de.drv.schiffe.spiel;
import java.util.Map;import java.util.Optional;
/** * Ein Spiel zwischen zwei Seiten: seine Phase, wer dran ist, die beiden Flotten und alle Schüsse. * Hier stehen die Regeln des Ablaufs – nichts über Netz, Tokens oder JSON. * * <p>Gerüst – die Methoden sind noch zu schreiben. */public class Spiel {
/** Ein neues Spiel – Spieler 1 ist da, die Phase ist WARTEN_AUF_GEGNER. */ public Spiel() { throw new UnsupportedOperationException("noch zu schreiben"); }
/** Spieler 2 tritt bei, die Phase wird AUFSTELLEN. */ public void gegnerTrittBei() { throw new UnsupportedOperationException("noch zu schreiben"); }
/** * Eine Seite stellt ihre Flotte auf. Haben beide aufgestellt, beginnt das Spiel – Seite EINS * schießt zuerst. * * @throws IllegalStateException wenn die Phase nicht AUFSTELLEN ist oder schon aufgestellt wurde */ public void stelleAuf(Seite seite, Flotte flotte) { throw new UnsupportedOperationException("noch zu schreiben"); }
/** * Eine Seite schießt auf das Feld der anderen. Danach ist die andere Seite dran – oder das * Spiel ist vorbei. * * @throws IllegalStateException wenn das Spiel nicht läuft, die Seite nicht dran ist * oder das Kästchen schon beschossen wurde */ public Ergebnis schiesse(Seite seite, Koordinate ziel) { throw new UnsupportedOperationException("noch zu schreiben"); }
public Phase getPhase() { throw new UnsupportedOperationException("noch zu schreiben"); }
/** Wer gerade schießen darf – leer, solange das Spiel nicht läuft. */ public Optional<Seite> amZug() { throw new UnsupportedOperationException("noch zu schreiben"); }
/** Die Schüsse, die eine Seite abgegeben hat, mit ihren Ergebnissen. */ public Map<Koordinate, Ergebnis> schuesseVon(Seite seite) { throw new UnsupportedOperationException("noch zu schreiben"); }
/** Wer gewonnen hat – leer, solange das Spiel nicht vorbei ist. */ public Optional<Seite> gewinner() { throw new UnsupportedOperationException("noch zu schreiben"); }
}- Das
Spielkennt nur Seiten – keine Namen, keine Tokens. Wer zu welcher Seite gehört, ist nicht seine Sache. - Jede Regel des Ablaufs steht hier: Schießen geht nur in
LAEUFT, nur für die Seite, die dran ist, nur auf ein noch nicht beschossenes Kästchen. Verstöße werden zurIllegalStateException. amZug()undgewinner()liefern einOptional: Solange das Spiel nicht läuft, ist niemand dran; solange es nicht vorbei ist, hat niemand gewonnen.
Der Vertrag: dienst
Abschnitt betitelt „Der Vertrag: dienst“Der Spieldienst ist die wichtigste Stelle des ganzen Entwurfs: Hier treffen
sich die beiden Hälften.
package de.drv.schiffe.dienst;
import de.drv.schiffe.spiel.Koordinate;import de.drv.schiffe.spiel.Ergebnis;
import java.util.List;
/** * Der Vertrag zwischen den Spielern und dem, der die Spiele führt – lokal im selben Programm * oder über das Netz. Die Konsole kennt nur dieses Interface. * * <p>Jeder Aufruf nach dem Beitreten nennt Spiel und Token. Am Token erkennt der Dienst, welche * Seite fragt – und dass sie es wirklich ist. */public interface Spieldienst {
/** Legt ein Spiel an; der Aufrufer ist Spieler 1. */ Beitritt neuesSpiel();
/** * Tritt einem Spiel als Spieler 2 bei. * * @throws SpielNichtGefunden wenn es das Spiel nicht gibt * @throws IllegalStateException wenn schon zwei Spieler da sind */ Beitritt beitreten(String spielId);
/** * Stellt die eigene Flotte auf. * * @throws IllegalArgumentException wenn die Aufstellung gegen eine Regel verstößt * @throws IllegalStateException wenn gerade nicht aufgestellt werden kann */ void aufstellen(String spielId, String token, List<Aufstellung> flotte);
/** Der Stand des Spiels aus der Sicht dessen, dem das Token gehört. */ Spielstand stand(String spielId, String token);
/** * Schießt auf das Feld des Gegners. * * @throws IllegalStateException wenn man nicht dran ist oder das Kästchen schon beschossen wurde */ Ergebnis schiessen(String spielId, String token, Koordinate ziel);
}Es gibt ihn zweimal:
Spieldienst (Interface) ▲ ▲ implements │ │ implements │ │ LokalerSpieldienst HttpSpieldienst (dienst) (client) führt die Spiele schickt jeden Aufruf im selben Programm als HTTP-Anfrage an den Server ▲ │ benutzt SpielServer (server)LokalerSpieldienstführt die Spiele wirklich: Er hält eine Map von Spiel-ID zuSpielund eine von Token zuSeite. Er prüft das Token, übersetztAufstellungen inSchiffe und baut aus demSpieldenSpielstandaus der Sicht des Fragenden. Weil der Server ihn für alle Spieler gleichzeitig benutzt, sind seine Methodensynchronized.HttpSpieldiensttut nur so: Er schickt jeden Aufruf als Anfrage an den Server und macht aus der Antwort wieder ein Ergebnis – und aus einem Fehlercode wieder die Exception, die der Vertrag verspricht.- Die
Konsolekennt nur das Interface.ClientStartentscheidet: ohne Argument lokal, mit einer Server-Adresse über das Netz. So kann man den ganzen Client bauen und spielen, bevor der Server fertig ist.
package de.drv.schiffe.client;
import de.drv.schiffe.dienst.LokalerSpieldienst;import de.drv.schiffe.dienst.Spieldienst;
import java.util.Scanner;
/** * Steckt den Client zusammen: ohne Argument mit einem lokalen Spieldienst (zum Ausprobieren * allein), mit einer Server-Adresse über das Netz. Die Konsole ist in beiden Fällen dieselbe. */public class ClientStart {
public static void main(String[] args) { Spieldienst dienst = args.length > 0 ? new HttpSpieldienst(args[0]) : new LokalerSpieldienst(); try (Scanner scanner = new Scanner(System.in)) { new Konsole(dienst, scanner).spiele(); } }
}Die Records Beitritt, Aufstellung und Spielstand sind die Daten, die über
den Vertrag gehen. Der Spielstand enthält nur, was ein Spieler wissen darf:
seine Schüsse und die des Gegners auf ihn – keine Schiffe des Gegners.
Das Protokoll: protokoll
Abschnitt betitelt „Das Protokoll: protokoll“package de.drv.schiffe.protokoll;
import java.util.List;import java.util.Map;
/** * Die Rümpfe der Anfragen und Antworten – nur einfache Typen (Text, Zahlen, Listen, Maps), damit * sie sich ohne Weiteres als JSON schreiben und lesen lassen. Eine Koordinate ist hier ein Text * wie "B7", ein Enum sein Name wie "TREFFER". */public final class Nachrichten {
private Nachrichten() { }
/** Antwort auf POST /spiele und POST /spiele/{id}/spieler */ public record BeitrittAntwort(String spielId, String token) { }
/** Ein Schiff im Rumpf von PUT /spiele/{id}/flotte – z. B. KREUZER, B2, WAAGERECHT */ public record SchiffNachricht(String typ, String anfang, String richtung) { }
/** Rumpf von PUT /spiele/{id}/flotte */ public record FlotteAnfrage(List<SchiffNachricht> schiffe) { }
/** Rumpf von POST /spiele/{id}/schuesse */ public record SchussAnfrage(String feld) { }
/** Antwort auf POST /spiele/{id}/schuesse */ public record SchussAntwort(String ergebnis) { }
/** Antwort auf GET /spiele/{id} */ public record StandAntwort(String phase, boolean amZug, Map<String, String> eigeneSchuesse, Map<String, String> gegnerischeSchuesse, Boolean gewonnen) { }
/** Rumpf jeder Fehlerantwort (4xx) */ public record Fehler(String fehler) { }
}Warum noch einmal eigene Records, wenn es doch Spielstand und Aufstellung
schon gibt? Weil sie verschiedene Aufgaben haben:
fachlicher Typ (dienst, spiel) |
Nachricht (protokoll) |
|
|---|---|---|
| Zweck | im Programm rechnen | über die Leitung schicken |
| Koordinate | Koordinate – geprüft, mit Methoden |
"B7" – ein Text |
| Ergebnis | Ergebnis.TREFFER – ein Enum |
"TREFFER" – ein Text |
| ändert sich, wenn … | sich die Regeln ändern | sich das Protokoll ändert |
Die Nachrichten bestehen nur aus Texten, Zahlen, Listen und Maps – so lassen sie sich ohne Zusatzarbeit als JSON schreiben und lesen, mit Jackson oder Gson. Und: Ändert jemand den Kern, ändert sich das Protokoll nicht von selbst. Ein Client, der gestern funktioniert hat, funktioniert auch morgen.
Protokoll sammelt die Pfade und den Namen des Token-Headers. Server und Client
benutzen dieselben Konstanten – ein Tippfehler im Pfad auf nur einer Seite
kann so nicht passieren.
Server und Client
Abschnitt betitelt „Server und Client“Der SpielServer hat genau eine Aufgabe: übersetzen.
- Aus Methode und Pfad bestimmen, welche Methode des
Spieldienstes gemeint ist. - Das Token aus dem Header
X-Spielerlesen, den Rumpf aus JSON in eine Nachricht. - Aus der Nachricht die fachlichen Typen machen – zum Beispiel mit
Koordinate.von("B7"). - Den Dienst aufrufen.
- Das Ergebnis als Nachricht in JSON zurückschicken – oder eine Exception in einen Statuscode übersetzen:
| Exception aus dem Dienst | Statuscode |
|---|---|
IllegalArgumentException (z. B. ungültige Aufstellung, K11) |
400 |
SpielNichtGefunden |
404 – oder 403 bei falschem Token |
IllegalStateException (nicht dran, falsche Phase, schon beschossen) |
409 |
Der HttpSpieldienst macht genau dasselbe in die andere Richtung.
Für die Anzeige liegt eine fertige Feldanzeige bei – ein Feld mit Schüssen als
Text:
A B C D E F G H I J 1 . . . . . . . . . . 2 . . . . . . . . . . 3 . . . . ~ . . . . . 4 . . . . . . . . . . 5 . . . . . . . . . . 6 . . . . . . . . . . 7 . X ~ . . . . . . . 8 . . . . . . . . . . 9 # # . . . . . . . .10 . . . . . . . . . .~ Wasser, X Treffer, # versenkt.
Wer baut was?
Abschnitt betitelt „Wer baut was?“Weil der Entwurf an klaren Grenzen geschnitten ist, lässt sich die Arbeit gut verteilen:
| Gruppe | baut | testet mit |
|---|---|---|
| Kern | Schiff, Flotte, Spiel |
JUnit – wie KoordinateTest im Gerüst |
| Dienst | LokalerSpieldienst |
JUnit – zwei Seiten, ein Spiel, ohne Netz |
| Server | SpielServer |
curl.exe – ohne Client |
| Client | Konsole, HttpSpieldienst |
zuerst gegen den LokalerSpieldienst, dann gegen den Server |
Die Gruppen Server und Client verbindet nur das Protokoll. Die Gruppen
Kern und Dienst verbindet nur das, was im Javadoc von Spiel und
Spieldienst steht. Wer sich daran hält, kann sich darauf verlassen, dass am
Ende alles zusammenpasst.