Zum Inhalt springen

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.

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

  • 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
client server
│ ╲ ╱ │
│ ▼ ▼ │
│ protokoll │ kennt niemanden
│ │
└──────▶ dienst ◀──────┘
│
▼
spiel kennt niemanden – alle dürfen es benutzen

Die 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 spiel lä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 server wird ersetzt.

Eine einfache Probe: Steht in einer Klasse aus spiel ein import aus dienst, server oder client, ist der Entwurf verletzt.

Koordinate.java
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).

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

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
Spiel.java
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 Spiel kennt 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 zur IllegalStateException.
  • amZug() und gewinner() liefern ein Optional: Solange das Spiel nicht läuft, ist niemand dran; solange es nicht vorbei ist, hat niemand gewonnen.

Der Spieldienst ist die wichtigste Stelle des ganzen Entwurfs: Hier treffen sich die beiden Hälften.

Spieldienst.java
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)
  • LokalerSpieldienst führt die Spiele wirklich: Er hält eine Map von Spiel-ID zu Spiel und eine von Token zu Seite. Er prüft das Token, übersetzt Aufstellungen in Schiffe und baut aus dem Spiel den Spielstand aus der Sicht des Fragenden. Weil der Server ihn für alle Spieler gleichzeitig benutzt, sind seine Methoden synchronized.
  • HttpSpieldienst tut 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 Konsole kennt nur das Interface. ClientStart entscheidet: ohne Argument lokal, mit einer Server-Adresse über das Netz. So kann man den ganzen Client bauen und spielen, bevor der Server fertig ist.
ClientStart.java
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.

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

Der SpielServer hat genau eine Aufgabe: übersetzen.

  1. Aus Methode und Pfad bestimmen, welche Methode des Spieldienstes gemeint ist.
  2. Das Token aus dem Header X-Spieler lesen, den Rumpf aus JSON in eine Nachricht.
  3. Aus der Nachricht die fachlichen Typen machen – zum Beispiel mit Koordinate.von("B7").
  4. Den Dienst aufrufen.
  5. 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:

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

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.