Schiffe versenken: Der Server
Der Server ist der Schiedsrichter: Er kennt beide Flotten, achtet auf die
Reihenfolge und beantwortet jeden Schuss. Dabei tut er erstaunlich wenig selbst –
die Regeln stehen im Kern, die Spiele führt der Spieldienst. Der Server
übersetzt: HTTP hinein, Aufrufe des Dienstes, HTTP hinaus.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- erklären, was ein Server mit jeder Anfrage tut
- Anfragen anhand von Methode und Pfad an die richtige Stelle leiten
- JSON mit Jackson lesen und schreiben
- Exceptions in die passenden Statuscodes übersetzen
- einen Server ohne Client testen – mit
curlund mit JUnit
Demo-Code: 34-schiffe-server
⤓ schiffe-server.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 34-schiffe-server 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, AttrappenSpieldienst.java, Aufstellung.java, Beitritt.java, LokalerSpieldienst.java, SpielNichtGefunden.java, Spieldienst.java, Spielstand.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, KoordinateTest.java
Das Demo-Projekt enthält das Gerüst aus dem Klassenmodell und dazu:
- den Rahmen des Servers – Routing, JSON, Fehlerbehandlung und Protokoll der Anfragen sind fertig,
- einen fertigen Endpunkt,
POST /spiele; die anderen vier antworten mit501 Not Implemented, - eine Attrappe des Spieldienstes, damit der Server laufen kann, bevor der echte Kern fertig ist,
- Jackson 3 in der
pom.xmlund eine Dateiflotte.jsonzum Ausprobieren.
Was der Server mit jeder Anfrage tut
Abschnitt betitelt „Was der Server mit jeder Anfrage tut“HTTP-Anfrage │ ▼1. Routing Methode und Pfad: Welcher Endpunkt ist gemeint? POST /spiele/7f3a/schuesse2. Lesen Token aus dem Header, Rumpf aus JSON X-Spieler, {"feld":"B7"}3. Übersetzen Nachricht → fachliche Typen Koordinate.von("B7")4. Aufrufen den Spieldienst dienst.schiessen(…)5. Antworten Ergebnis → Nachricht → JSON – oder Fehler → Status {"ergebnis":"TREFFER"} │ ▼HTTP-AntwortJeder Endpunkt hat dieselben fünf Schritte. Nur Schritt 4 ist bei jedem anders – alles andere ist Handwerk, und dieses Handwerk steckt im Rahmen.
SpielServer.java – der Rahmen im Ganzen
package de.drv.schiffe.server;
import de.drv.schiffe.dienst.Beitritt;import de.drv.schiffe.dienst.SpielNichtGefunden;import de.drv.schiffe.dienst.Spieldienst;import de.drv.schiffe.protokoll.Nachrichten.BeitrittAntwort;import de.drv.schiffe.protokoll.Nachrichten.Fehler;import de.drv.schiffe.protokoll.Protokoll;
import com.sun.net.httpserver.HttpExchange;import com.sun.net.httpserver.HttpServer;
import tools.jackson.core.JacksonException;import tools.jackson.databind.json.JsonMapper;
import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.net.InetSocketAddress;import java.util.concurrent.Executors;import java.util.regex.Matcher;import java.util.regex.Pattern;
/** * Übersetzt HTTP in Aufrufe des {@link Spieldienst}es – und die Ergebnisse zurück in HTTP. * * <p>Der Rahmen ist fertig: Routing, JSON lesen und schreiben, Fehler in Statuscodes übersetzen, * jede Anfrage protokollieren. Umgesetzt ist ein Endpunkt, {@code POST /spiele}; die anderen vier * antworten noch mit {@code 501 Not Implemented}. */public class SpielServer {
// Die Pfade mit einer Spiel-ID – die ID steht in Gruppe 1 private static final Pattern SPIEL = Pattern.compile("/spiele/([^/]+)"); private static final Pattern SPIELER = Pattern.compile("/spiele/([^/]+)/spieler"); private static final Pattern FLOTTE = Pattern.compile("/spiele/([^/]+)/flotte"); private static final Pattern SCHUESSE = Pattern.compile("/spiele/([^/]+)/schuesse");
private final Spieldienst dienst; private final int port; private final JsonMapper json = JsonMapper.builder().build(); private HttpServer server;
/** @param port 0 heißt: irgendein freier Port – praktisch für Tests */ public SpielServer(Spieldienst dienst, int port) { this.dienst = dienst; this.port = port; }
public void starte() throws IOException { server = HttpServer.create(new InetSocketAddress(port), 0); server.createContext(Protokoll.SPIELE, this::bearbeite); // Jede Anfrage in einem eigenen virtuellen Thread – mehrere Spieler gleichzeitig server.setExecutor(Executors.newVirtualThreadPerTaskExecutor()); server.start(); System.out.println("Spiel-Server auf http://localhost:" + getPort()); }
public void stoppe() { server.stop(0); }
/** Der tatsächliche Port – auch wenn beim Start 0 angegeben war. */ public int getPort() { return server.getAddress().getPort(); }
// ----- Eingang: jede Anfrage kommt hier an -------------------------------------------
private void bearbeite(HttpExchange anfrage) { long start = System.nanoTime(); int status; try { status = leiteWeiter(anfrage); } catch (FehlendesToken e) { status = fehler(anfrage, 403, e.getMessage()); } catch (SpielNichtGefunden e) { status = fehler(anfrage, 404, e.getMessage()); } catch (JacksonException e) { status = fehler(anfrage, 400, "Kein gültiges JSON: " + e.getOriginalMessage()); } catch (IllegalArgumentException e) { status = fehler(anfrage, 400, e.getMessage()); } catch (IllegalStateException e) { status = fehler(anfrage, 409, e.getMessage()); } catch (Exception e) { e.printStackTrace(); // unerwartet – ein Fehler im Server selbst status = fehler(anfrage, 500, "Interner Fehler"); } long millis = (System.nanoTime() - start) / 1_000_000; System.out.printf("%-4s %-40s %d %d ms%n", anfrage.getRequestMethod(), anfrage.getRequestURI(), status, millis); }
/** Routing: Methode und Pfad bestimmen, welcher Endpunkt zuständig ist. */ private int leiteWeiter(HttpExchange anfrage) throws IOException { String methode = anfrage.getRequestMethod(); String pfad = anfrage.getRequestURI().getPath();
if (pfad.equals(Protokoll.SPIELE) && methode.equals("POST")) { return neuesSpiel(anfrage); } Matcher spieler = SPIELER.matcher(pfad); if (spieler.matches() && methode.equals("POST")) { return nichtUmgesetzt(anfrage); // beitreten } Matcher flotte = FLOTTE.matcher(pfad); if (flotte.matches() && methode.equals("PUT")) { return nichtUmgesetzt(anfrage); // aufstellen } Matcher schuesse = SCHUESSE.matcher(pfad); if (schuesse.matches() && methode.equals("POST")) { return nichtUmgesetzt(anfrage); // schießen } Matcher spiel = SPIEL.matcher(pfad); if (spiel.matches() && methode.equals("GET")) { return nichtUmgesetzt(anfrage); // Stand abfragen } return fehler(anfrage, 404, "Unbekannt: " + methode + " " + pfad); }
// ----- Endpunkte ---------------------------------------------------------------------
/** POST /spiele – legt ein Spiel an; der Aufrufer ist Spieler 1. */ private int neuesSpiel(HttpExchange anfrage) throws IOException { Beitritt beitritt = dienst.neuesSpiel(); return antworte(anfrage, 201, new BeitrittAntwort(beitritt.spielId(), beitritt.token())); }
private int nichtUmgesetzt(HttpExchange anfrage) throws IOException { return fehler(anfrage, 501, "Noch nicht umgesetzt"); }
// ----- Werkzeuge ---------------------------------------------------------------------
/** Das Token aus dem Header X-Spieler – oder eine FehlendesToken-Exception. */ String token(HttpExchange anfrage) { String token = anfrage.getRequestHeaders().getFirst(Protokoll.TOKEN_HEADER); if (token == null || token.isBlank()) { throw new FehlendesToken(); } return token; }
/** Liest den Rumpf der Anfrage als JSON in einen Record vom Typ {@code typ}. */ <T> T lies(HttpExchange anfrage, Class<T> typ) throws IOException { try (InputStream rumpf = anfrage.getRequestBody()) { return json.readValue(rumpf, typ); } }
/** Schreibt eine Nachricht als JSON mit diesem Statuscode und liefert den Statuscode. */ int antworte(HttpExchange anfrage, int status, Object nachricht) throws IOException { byte[] bytes = json.writeValueAsBytes(nachricht); anfrage.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8"); anfrage.sendResponseHeaders(status, bytes.length); try (OutputStream aus = anfrage.getResponseBody()) { aus.write(bytes); } return status; }
/** Eine Antwort ohne Rumpf, z. B. 204 No Content. */ int antworteOhneRumpf(HttpExchange anfrage, int status) throws IOException { anfrage.sendResponseHeaders(status, -1); // -1: es kommt kein Rumpf anfrage.close(); return status; }
/** Eine Fehlerantwort mit {@code {"fehler": "…"}} – und wenn selbst das nicht klappt, aufgeben. */ private int fehler(HttpExchange anfrage, int status, String meldung) { try { return antworte(anfrage, status, new Fehler(meldung)); } catch (IOException e) { anfrage.close(); return status; } }
}1. Routing
Abschnitt betitelt „1. Routing“Der HttpServer kennt nur Präfixe: createContext("/spiele", …) nimmt jede
Anfrage an, deren Pfad mit /spiele beginnt. Welche genau gemeint ist, muss der
Server selbst herausfinden. Dafür eignen sich reguläre Ausdrücke aus dem
Kapitel Reguläre Ausdrücke:
private static final Pattern SCHUESSE = Pattern.compile("/spiele/([^/]+)/schuesse");
Matcher schuesse = SCHUESSE.matcher(pfad);if (schuesse.matches() && methode.equals("POST")) { return schiessen(anfrage, schuesse.group(1)); // group(1) ist die Spiel-ID}[^/]+ heißt: ein oder mehrere Zeichen, aber kein Schrägstrich – genau ein
Abschnitt des Pfads. In der Gruppe steht danach die Spiel-ID.
Weil matches() den ganzen Pfad prüft, passt /spiele/([^/]+) nicht auf
/spiele/7f3a/schuesse – jeder Pfad landet bei genau einem Muster. Und weil
zusätzlich die Methode geprüft wird, sind GET /spiele/7f3a und
DELETE /spiele/7f3a zwei verschiedene Dinge. Passt nichts, gibt es 404.
2. und 5. Lesen und Antworten
Abschnitt betitelt „2. und 5. Lesen und Antworten“Der HttpExchange
Abschnitt betitelt „Der HttpExchange“Alles über eine Anfrage steckt in einem HttpExchange:
| Methode | liefert |
|---|---|
getRequestMethod() |
"GET", "POST" … |
getRequestURI().getPath() |
den Pfad, z. B. /spiele/7f3a/schuesse |
getRequestHeaders().getFirst("X-Spieler") |
einen Header – oder null |
getRequestBody() |
den Rumpf als InputStream |
getResponseHeaders() |
die Header der Antwort, zum Setzen |
sendResponseHeaders(status, laenge) |
schickt Statuszeile und Header |
getResponseBody() |
der Rumpf der Antwort als OutputStream |
JSON mit Jackson
Abschnitt betitelt „JSON mit Jackson“In der pom.xml steht eine einzige neue Abhängigkeit:
<dependency> <groupId>tools.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>3.2.4</version></dependency>Ein JsonMapper übersetzt in beide Richtungen – Records funktionieren dabei
ohne jede Zusatzarbeit, die Namen der Felder werden zu den Namen im JSON:
private final JsonMapper json = JsonMapper.builder().build();
/** Liest den Rumpf der Anfrage als JSON in einen Record vom Typ {@code typ}. */<T> T lies(HttpExchange anfrage, Class<T> typ) throws IOException { try (InputStream rumpf = anfrage.getRequestBody()) { return json.readValue(rumpf, typ); }}
/** Schreibt eine Nachricht als JSON mit diesem Statuscode und liefert den Statuscode. */int antworte(HttpExchange anfrage, int status, Object nachricht) throws IOException { byte[] bytes = json.writeValueAsBytes(nachricht); anfrage.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8"); anfrage.sendResponseHeaders(status, bytes.length); try (OutputStream aus = anfrage.getResponseBody()) { aus.write(bytes); } return status;}lies(anfrage, SchussAnfrage.class)macht aus{"feld":"B7"}einSchussAnfrage("B7").antworte(anfrage, 200, new SchussAntwort("TREFFER"))macht daraus{"ergebnis":"TREFFER"}.liesist generisch –<T>aus dem Kapitel Generics: Eine Methode für jeden Typ von Nachricht.- Jackson 3 wirft bei kaputtem JSON eine
JacksonException. Sie ist ungeprüft – der Rahmen fängt sie zentral und macht eine400daraus.
3. und 4. Ein Endpunkt
Abschnitt betitelt „3. und 4. Ein Endpunkt“So sieht der fertige Endpunkt im Demo-Projekt aus:
/** POST /spiele – legt ein Spiel an; der Aufrufer ist Spieler 1. */private int neuesSpiel(HttpExchange anfrage) throws IOException { Beitritt beitritt = dienst.neuesSpiel(); return antworte(anfrage, 201, new BeitrittAntwort(beitritt.spielId(), beitritt.token()));}Drei Zeilen: Dienst aufrufen, Ergebnis in eine Nachricht verpacken, antworten. Bei den anderen Endpunkten kommt Schritt 2 und 3 dazu – das Token lesen und die Nachricht in fachliche Typen übersetzen:
| Nachricht (Text) | fachlicher Typ | Übersetzung |
|---|---|---|
"B7" |
Koordinate |
Koordinate.von("B7") |
"KREUZER" |
Schiffstyp |
Schiffstyp.valueOf("KREUZER") |
"WAAGERECHT" |
Richtung |
Richtung.valueOf("WAAGERECHT") |
Ergebnis.TREFFER |
"TREFFER" |
ergebnis.name() |
Koordinate als Schlüssel einer Map |
"B7" |
koordinate.toString() |
Ist ein Text ungültig, werfen von und valueOf eine
IllegalArgumentException – und der Rahmen macht daraus eine 400. Der Endpunkt
muss sich darum nicht kümmern.
Fehler werden zu Statuscodes
Abschnitt betitelt „Fehler werden zu Statuscodes“Jede Anfrage läuft durch eine Methode mit einem try und mehreren catch:
try { status = leiteWeiter(anfrage);} catch (FehlendesToken e) { status = fehler(anfrage, 403, e.getMessage());} catch (SpielNichtGefunden e) { status = fehler(anfrage, 404, e.getMessage());} catch (JacksonException e) { status = fehler(anfrage, 400, "Kein gültiges JSON: " + e.getOriginalMessage());} catch (IllegalArgumentException e) { status = fehler(anfrage, 400, e.getMessage());} catch (IllegalStateException e) { status = fehler(anfrage, 409, e.getMessage());} catch (Exception e) { e.printStackTrace(); // unerwartet – ein Fehler im Server selbst status = fehler(anfrage, 500, "Interner Fehler");}- So steht die Übersetzung von Exception in Statuscode an einer Stelle.
Kein Endpunkt muss
tryschreiben. - Jeder Fehler kommt als
{"fehler": "…"}zurück – mit der Meldung der Exception. Der Client kann sie anzeigen. - Der letzte
catchfängt alles Unerwartete. Ohne ihn würde der Server bei einerNullPointerExceptiongar nicht antworten – siehe unten.500heißt: Der Fehler liegt beim Server, nicht in der Anfrage.
Das Token
Abschnitt betitelt „Das Token“token(anfrage) liest den Header X-Spieler. Fehlt er, wirft der Rahmen eine
eigene FehlendesToken-Exception – und daraus wird 403. Ob das Token gültig
ist, prüft der Spieldienst: Gehört es nicht zum Spiel, wirft er
SpielNichtGefunden.
Mehrere Spieler gleichzeitig
Abschnitt betitelt „Mehrere Spieler gleichzeitig“server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());Ohne diese Zeile bearbeitet der HttpServer alle Anfragen nacheinander in
einem einzigen Thread. Mit ihr bekommt jede Anfrage einen eigenen virtuellen
Thread – siehe Parallelität. Das heißt aber
auch: Anna und Ben können gleichzeitig im Spieldienst sein. Deshalb sind die
Methoden des LokalerSpieldienst synchronized.
Die Attrappe
Abschnitt betitelt „Die Attrappe“package de.drv.schiffe.dienst;
import de.drv.schiffe.spiel.Ergebnis;import de.drv.schiffe.spiel.Koordinate;import de.drv.schiffe.spiel.Phase;
import java.util.List;import java.util.Map;
/** * Eine <em>Attrappe</em>: erfüllt den Vertrag {@link Spieldienst}, spielt aber nicht wirklich. Sie * liefert immer dieselben, festen Antworten. * * <p>Wozu? Wer am Server oder am Client arbeitet, kann damit loslegen, bevor der echte Kern fertig * ist – und sieht sofort, ob Anfragen und Antworten richtig übersetzt werden. */public class AttrappenSpieldienst implements Spieldienst {
private static final String SPIEL = "attrappe";
@Override public Beitritt neuesSpiel() { return new Beitritt(SPIEL, "token-eins"); }
@Override public Beitritt beitreten(String spielId) { pruefe(spielId); return new Beitritt(SPIEL, "token-zwei"); }
@Override public void aufstellen(String spielId, String token, List<Aufstellung> flotte) { pruefe(spielId); if (flotte.size() != 5) { throw new IllegalArgumentException("Eine Flotte hat fünf Schiffe, nicht " + flotte.size()); } }
@Override public Spielstand stand(String spielId, String token) { pruefe(spielId); return new Spielstand(Phase.LAEUFT, true, Map.of(Koordinate.von("B7"), Ergebnis.TREFFER), Map.of(Koordinate.von("D4"), Ergebnis.WASSER), null); }
@Override public Ergebnis schiessen(String spielId, String token, Koordinate ziel) { pruefe(spielId); return ziel.equals(Koordinate.von("B7")) ? Ergebnis.TREFFER : Ergebnis.WASSER; }
private static void pruefe(String spielId) { if (!SPIEL.equals(spielId)) { throw new SpielNichtGefunden("Kein Spiel mit der ID " + spielId); } }
}Eine Attrappe erfüllt den Vertrag, spielt aber nicht wirklich: Es gibt nur ein
Spiel mit der ID attrappe, und auf B7 ist immer ein Treffer. Das reicht, um
den Server zu bauen und zu prüfen, ob er richtig übersetzt – während eine andere
Gruppe noch am Kern arbeitet. Gestartet wird der Server dann mit dem Argument
attrappe.
Ausprobieren mit curl
Abschnitt betitelt „Ausprobieren mit curl“-
Starte
ServerStartmit dem Argumentattrappe. Auf der Konsole erscheint für jede Anfrage eine Zeile:Terminal-Fenster Spiel-Server auf http://localhost:8080POST /spiele 201 39 msPOST /spiele/attrappe/schuesse 501 1 ms -
Ein Spiel anlegen:
PowerShell curl.exe -i -X POST http://localhost:8080/spieleTerminal-Fenster HTTP/1.1 201 CreatedContent-type: application/json; charset=utf-8Content-length: 43{"spielId":"attrappe","token":"token-eins"} -
Die anderen Endpunkte melden sich noch mit
501:PowerShell curl.exe -X POST -H "X-Spieler: token-eins" -d '{"feld":"B7"}' http://localhost:8080/spiele/attrappe/schuesseTerminal-Fenster {"fehler":"Noch nicht umgesetzt"}
So sieht ein Spiel aus, wenn alles fertig ist
Abschnitt betitelt „So sieht ein Spiel aus, wenn alles fertig ist“Mit dem echten Spieldienst (ohne attrappe) und allen Endpunkten – die IDs und
Tokens sind bei jedem Spiel andere:
POST /spiele → 201 {"spielId":"29a4df96-…","token":"4aae9754-…"}POST /spiele/29a4df96-…/spieler → 201 {"spielId":"29a4df96-…","token":"04350839-…"}PUT /spiele/…/flotte (Anna) → 204PUT /spiele/…/flotte (Ben) → 204POST /spiele/…/schuesse (Ben) B2 → 409 {"fehler":"Du bist nicht dran"}POST /spiele/…/schuesse (Anna) B2→ 200 {"ergebnis":"TREFFER"}POST /spiele/…/schuesse (Ben) E5 → 200 {"ergebnis":"WASSER"}POST /spiele/…/schuesse (Anna) K3→ 400 {"fehler":"Keine Koordinate: K3"}GET /spiele/… (Anna) → 200 {"phase":"LAEUFT","amZug":true,"eigeneSchuesse":{"B2":"TREFFER"},"gegnerischeSchuesse":{"E5":"WASSER"},"gewonnen":null}GET /spiele/… ohne Token → 403 {"fehler":"Header X-Spieler fehlt"}Testen mit JUnit
Abschnitt betitelt „Testen mit JUnit“curl ist gut zum Ausprobieren, aber nach jeder Änderung alles von Hand zu
wiederholen, ist mühsam. Ein JUnit-Test kann einen echten Server starten und
mit dem HttpClient gegen ihn sprechen:
@BeforeEachvoid starte() throws IOException { server = new SpielServer(new LokalerSpieldienst(), 0); // Port 0: irgendein freier server.starte(); adresse = "http://localhost:" + server.getPort();}
@AfterEachvoid stoppe() { server.stoppe();}- Port 0 heißt: Das Betriebssystem sucht einen freien Port aus. So kommen sich der Test und ein laufender Server auf 8080 nicht in die Quere.
getPort()verrät danach, welcher es geworden ist.@BeforeEachund@AfterEachlaufen vor und nach jedem Test – jeder Test bekommt einen frischen Server.
Übung: Die übrigen vier Endpunkte
Abschnitt betitelt „Übung: Die übrigen vier Endpunkte“Arbeite im Demo-Projekt 34-schiffe-server. Teste jeden Endpunkt zuerst mit der
Attrappe und curl.exe.
-
Beitreten:
POST /spiele/{id}/spielerantwortet mit201und einerBeitrittAntwort. Mit der Attrappe: Die IDattrappelieferttoken-zwei, jede andere404. -
Schießen:
POST /spiele/{id}/schuesseliest das Token und eineSchussAnfrage, übersetzt das Feld in eineKoordinateund antwortet mit einerSchussAntwort. Probiere auchK3, kaputtes JSON und eine Anfrage ohne Token – welcher Statuscode kommt jeweils? -
Aufstellen und Stand:
PUT /spiele/{id}/flotteliest eineFlotteAnfrage, macht aus jederSchiffNachrichteineAufstellungund antwortet mit204ohne Rumpf. Zum Ausprobieren liegtflotte.jsonim Projekt.GET /spiele/{id}übersetzt denSpielstandin eineStandAntwort– die Maps mitKoordinateundErgebniswerden zu Maps aus Texten.
-
Für Schnelle: Ein JUnit-Test
SpielServerTest, der einen Server auf Port 0 startet und den Ablauf von oben durchspielt: anlegen, beitreten, beide Flotten aufstellen, ein Schuss, Stand abfragen. Und ein zweiter Test für die Fehlercodes 400, 403, 404 und 409. Für einen echten Ablauf braucht es den echten Kern – also denLokalerSpieldienstder Kern-Gruppe oder die Lösung.
Lösung
Die vier neuen Endpunkte folgen alle demselben Muster. Dazu kommen zwei kleine Helfer:
pflicht(wert, name)meldet ein fehlendes Feld in der Nachricht als400– sonst würdevalueOf(null)eineNullPointerExceptionwerfen, und daraus würde eine500.alsTextübersetzt die Maps desSpielstands in Maps aus Texten, nach Feld sortiert in einerTreeMap.
package de.drv.schiffe.server;
import de.drv.schiffe.dienst.Aufstellung;import de.drv.schiffe.dienst.Beitritt;import de.drv.schiffe.dienst.SpielNichtGefunden;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.Fehler;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 com.sun.net.httpserver.HttpExchange;import com.sun.net.httpserver.HttpServer;
import tools.jackson.core.JacksonException;import tools.jackson.databind.json.JsonMapper;
import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.net.InetSocketAddress;import java.util.ArrayList;import java.util.List;import java.util.Map;import java.util.TreeMap;import java.util.concurrent.Executors;import java.util.regex.Matcher;import java.util.regex.Pattern;
/** * Übersetzt HTTP in Aufrufe des {@link Spieldienst}es – und die Ergebnisse zurück in HTTP. * * <p>Rahmen: Routing, JSON lesen und schreiben, Fehler in Statuscodes übersetzen, jede Anfrage * protokollieren. Dazu alle fünf Endpunkte des Protokolls. */public class SpielServer {
// Die Pfade mit einer Spiel-ID – die ID steht in Gruppe 1 private static final Pattern SPIEL = Pattern.compile("/spiele/([^/]+)"); private static final Pattern SPIELER = Pattern.compile("/spiele/([^/]+)/spieler"); private static final Pattern FLOTTE = Pattern.compile("/spiele/([^/]+)/flotte"); private static final Pattern SCHUESSE = Pattern.compile("/spiele/([^/]+)/schuesse");
private final Spieldienst dienst; private final int port; private final JsonMapper json = JsonMapper.builder().build(); private HttpServer server;
/** @param port 0 heißt: irgendein freier Port – praktisch für Tests */ public SpielServer(Spieldienst dienst, int port) { this.dienst = dienst; this.port = port; }
public void starte() throws IOException { server = HttpServer.create(new InetSocketAddress(port), 0); server.createContext(Protokoll.SPIELE, this::bearbeite); // Jede Anfrage in einem eigenen virtuellen Thread – mehrere Spieler gleichzeitig server.setExecutor(Executors.newVirtualThreadPerTaskExecutor()); server.start(); System.out.println("Spiel-Server auf http://localhost:" + getPort()); }
public void stoppe() { server.stop(0); }
/** Der tatsächliche Port – auch wenn beim Start 0 angegeben war. */ public int getPort() { return server.getAddress().getPort(); }
// ----- Eingang: jede Anfrage kommt hier an -------------------------------------------
private void bearbeite(HttpExchange anfrage) { long start = System.nanoTime(); int status; try { status = leiteWeiter(anfrage); } catch (FehlendesToken e) { status = fehler(anfrage, 403, e.getMessage()); } catch (SpielNichtGefunden e) { status = fehler(anfrage, 404, e.getMessage()); } catch (JacksonException e) { status = fehler(anfrage, 400, "Kein gültiges JSON: " + e.getOriginalMessage()); } catch (IllegalArgumentException e) { status = fehler(anfrage, 400, e.getMessage()); } catch (IllegalStateException e) { status = fehler(anfrage, 409, e.getMessage()); } catch (Exception e) { e.printStackTrace(); // unerwartet – ein Fehler im Server selbst status = fehler(anfrage, 500, "Interner Fehler"); } long millis = (System.nanoTime() - start) / 1_000_000; System.out.printf("%-4s %-40s %d %d ms%n", anfrage.getRequestMethod(), anfrage.getRequestURI(), status, millis); }
/** Routing: Methode und Pfad bestimmen, welcher Endpunkt zuständig ist. */ private int leiteWeiter(HttpExchange anfrage) throws IOException { String methode = anfrage.getRequestMethod(); String pfad = anfrage.getRequestURI().getPath();
if (pfad.equals(Protokoll.SPIELE) && methode.equals("POST")) { return neuesSpiel(anfrage); } Matcher spieler = SPIELER.matcher(pfad); if (spieler.matches() && methode.equals("POST")) { return beitreten(anfrage, spieler.group(1)); } Matcher flotte = FLOTTE.matcher(pfad); if (flotte.matches() && methode.equals("PUT")) { return aufstellen(anfrage, flotte.group(1)); } Matcher schuesse = SCHUESSE.matcher(pfad); if (schuesse.matches() && methode.equals("POST")) { return schiessen(anfrage, schuesse.group(1)); } Matcher spiel = SPIEL.matcher(pfad); if (spiel.matches() && methode.equals("GET")) { return stand(anfrage, spiel.group(1)); } return fehler(anfrage, 404, "Unbekannt: " + methode + " " + pfad); }
// ----- Endpunkte ---------------------------------------------------------------------
/** POST /spiele – legt ein Spiel an; der Aufrufer ist Spieler 1. */ private int neuesSpiel(HttpExchange anfrage) throws IOException { Beitritt beitritt = dienst.neuesSpiel(); return antworte(anfrage, 201, new BeitrittAntwort(beitritt.spielId(), beitritt.token())); }
/** POST /spiele/{id}/spieler – tritt als Spieler 2 bei. */ private int beitreten(HttpExchange anfrage, String spielId) throws IOException { Beitritt beitritt = dienst.beitreten(spielId); return antworte(anfrage, 201, new BeitrittAntwort(beitritt.spielId(), beitritt.token())); }
/** PUT /spiele/{id}/flotte – stellt die eigene Flotte auf. */ private int aufstellen(HttpExchange anfrage, String spielId) throws IOException { String token = token(anfrage); FlotteAnfrage nachricht = lies(anfrage, FlotteAnfrage.class); if (nachricht.schiffe() == null) { throw new IllegalArgumentException("Es fehlt die Liste \"schiffe\""); } // Nachricht → fachliche Typen: Texte werden zu Enums und Koordinaten (ungültig: IllegalArgumentException) 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); return antworteOhneRumpf(anfrage, 204); }
/** POST /spiele/{id}/schuesse – schießt auf das Feld des Gegners. */ private int schiessen(HttpExchange anfrage, String spielId) throws IOException { String token = token(anfrage); SchussAnfrage nachricht = lies(anfrage, SchussAnfrage.class); Ergebnis ergebnis = dienst.schiessen(spielId, token, Koordinate.von(nachricht.feld())); return antworte(anfrage, 200, new SchussAntwort(ergebnis.name())); }
/** GET /spiele/{id} – der Stand aus der Sicht dessen, der fragt. */ private int stand(HttpExchange anfrage, String spielId) throws IOException { Spielstand stand = dienst.stand(spielId, token(anfrage)); return antworte(anfrage, 200, new StandAntwort( stand.phase().name(), stand.amZug(), alsText(stand.eigeneSchuesse()), alsText(stand.gegnerischeSchuesse()), stand.gewonnen())); }
/** Ein Feld, das in der Nachricht stehen muss – fehlt es, ist die Anfrage falsch (400). */ private static String pflicht(String wert, String name) { if (wert == null) { throw new IllegalArgumentException("Es fehlt \"" + name + "\""); } return wert; }
/** Fachliche Typen → Nachricht: Koordinaten und Ergebnisse als Texte, nach Feld sortiert. */ 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; }
// ----- Werkzeuge ---------------------------------------------------------------------
/** Das Token aus dem Header X-Spieler – oder eine FehlendesToken-Exception. */ String token(HttpExchange anfrage) { String token = anfrage.getRequestHeaders().getFirst(Protokoll.TOKEN_HEADER); if (token == null || token.isBlank()) { throw new FehlendesToken(); } return token; }
/** Liest den Rumpf der Anfrage als JSON in einen Record vom Typ {@code typ}. */ <T> T lies(HttpExchange anfrage, Class<T> typ) throws IOException { try (InputStream rumpf = anfrage.getRequestBody()) { return json.readValue(rumpf, typ); } }
/** Schreibt eine Nachricht als JSON mit diesem Statuscode und liefert den Statuscode. */ int antworte(HttpExchange anfrage, int status, Object nachricht) throws IOException { byte[] bytes = json.writeValueAsBytes(nachricht); anfrage.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8"); anfrage.sendResponseHeaders(status, bytes.length); try (OutputStream aus = anfrage.getResponseBody()) { aus.write(bytes); } return status; }
/** Eine Antwort ohne Rumpf, z. B. 204 No Content. */ int antworteOhneRumpf(HttpExchange anfrage, int status) throws IOException { anfrage.sendResponseHeaders(status, -1); // -1: es kommt kein Rumpf anfrage.close(); return status; }
/** Eine Fehlerantwort mit {@code {"fehler": "…"}} – und wenn selbst das nicht klappt, aufgeben. */ private int fehler(HttpExchange anfrage, int status, String meldung) { try { return antworte(anfrage, status, new Fehler(meldung)); } catch (IOException e) { anfrage.close(); return status; } }
}Lösung
JsonNode ist die Art, wie Jackson JSON liest, wenn es keinen passenden Record
gibt: json.readTree(text) liefert einen Baum, get("token").asString() einen
Wert daraus. Für Tests ist das bequem.
package de.drv.schiffe.server;
import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertTrue;
import de.drv.schiffe.dienst.LokalerSpieldienst;
import java.io.IOException;import java.net.URI;import java.net.http.HttpClient;import java.net.http.HttpRequest;import java.net.http.HttpResponse;
import org.junit.jupiter.api.AfterEach;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.DisplayName;import org.junit.jupiter.api.Test;
import tools.jackson.databind.JsonNode;import tools.jackson.databind.json.JsonMapper;
/** Startet einen echten Server auf einem freien Port und spricht HTTP mit ihm. */class SpielServerTest {
private static final String FLOTTE = """ {"schiffe": [ {"typ": "FLUGZEUGTRAEGER", "anfang": "A1", "richtung": "WAAGERECHT"}, {"typ": "SCHLACHTSCHIFF", "anfang": "A3", "richtung": "WAAGERECHT"}, {"typ": "KREUZER", "anfang": "A5", "richtung": "WAAGERECHT"}, {"typ": "U_BOOT", "anfang": "A7", "richtung": "WAAGERECHT"}, {"typ": "ZERSTOERER", "anfang": "A9", "richtung": "WAAGERECHT"} ]}""";
private final JsonMapper json = JsonMapper.builder().build(); private final HttpClient client = HttpClient.newHttpClient(); private SpielServer server; private String adresse;
@BeforeEach void starte() throws IOException { server = new SpielServer(new LokalerSpieldienst(), 0); server.starte(); adresse = "http://localhost:" + server.getPort(); }
@AfterEach void stoppe() { server.stoppe(); client.close(); }
private HttpResponse<String> sende(String methode, String pfad, String token, String rumpf) throws Exception { HttpRequest.Builder anfrage = HttpRequest.newBuilder(URI.create(adresse + pfad)) .method(methode, rumpf == null ? HttpRequest.BodyPublishers.noBody() : HttpRequest.BodyPublishers.ofString(rumpf)); if (token != null) { anfrage.header("X-Spieler", token); } return client.send(anfrage.build(), HttpResponse.BodyHandlers.ofString()); }
@Test @DisplayName("Ein Spiel über HTTP: anlegen, beitreten, aufstellen, schießen, Stand") void ablauf() throws Exception { HttpResponse<String> angelegt = sende("POST", "/spiele", null, null); assertEquals(201, angelegt.statusCode()); JsonNode anna = json.readTree(angelegt.body()); String id = anna.get("spielId").asString(); String annasToken = anna.get("token").asString();
HttpResponse<String> beigetreten = sende("POST", "/spiele/" + id + "/spieler", null, null); assertEquals(201, beigetreten.statusCode()); String bensToken = json.readTree(beigetreten.body()).get("token").asString();
assertEquals(204, sende("PUT", "/spiele/" + id + "/flotte", annasToken, FLOTTE).statusCode()); assertEquals(204, sende("PUT", "/spiele/" + id + "/flotte", bensToken, FLOTTE).statusCode());
HttpResponse<String> schuss = sende("POST", "/spiele/" + id + "/schuesse", annasToken, "{\"feld\":\"A1\"}"); assertEquals(200, schuss.statusCode()); assertEquals("TREFFER", json.readTree(schuss.body()).get("ergebnis").asString());
JsonNode stand = json.readTree(sende("GET", "/spiele/" + id, bensToken, null).body()); assertEquals("LAEUFT", stand.get("phase").asString()); assertTrue(stand.get("amZug").asBoolean()); assertEquals("TREFFER", stand.get("gegnerischeSchuesse").get("A1").asString()); }
@Test @DisplayName("Fehler werden zu Statuscodes") void fehler() throws Exception { JsonNode anna = json.readTree(sende("POST", "/spiele", null, null).body()); String id = anna.get("spielId").asString(); String token = anna.get("token").asString();
assertEquals(404, sende("GET", "/spiele/gibt-es-nicht", token, null).statusCode()); assertEquals(403, sende("GET", "/spiele/" + id, null, null).statusCode()); assertEquals(404, sende("GET", "/spiele/" + id, "falsches-token", null).statusCode()); assertEquals(409, sende("POST", "/spiele/" + id + "/schuesse", token, "{\"feld\":\"A1\"}").statusCode());
sende("POST", "/spiele/" + id + "/spieler", null, null); assertEquals(409, sende("POST", "/spiele/" + id + "/spieler", null, null).statusCode()); assertEquals(400, sende("PUT", "/spiele/" + id + "/flotte", token, "{\"schiffe\": []}").statusCode()); assertEquals(400, sende("PUT", "/spiele/" + id + "/flotte", token, "kein json").statusCode()); assertEquals(400, sende("PUT", "/spiele/" + id + "/flotte", token, "{\"schiffe\": [{\"typ\": \"FLOSS\"}]}").statusCode()); assertEquals(404, sende("DELETE", "/spiele/" + id, token, null).statusCode()); }
}Lösung
Der echte Spieldienst – für alle, die den Server mit einem richtigen Spiel
ausprobieren wollen, bevor die Kern-Gruppe fertig ist. Ein Token gehört zu einem
Platz: einem Spiel und einer Seite. Ein Token aus einem anderen Spiel wird
abgelehnt.
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; }
}Lösung
package de.drv.schiffe.spiel;
import java.util.Collections;import java.util.EnumMap;import java.util.LinkedHashMap;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. */public class Spiel {
private Phase phase = Phase.WARTEN_AUF_GEGNER; private final Map<Seite, Flotte> flotten = new EnumMap<>(Seite.class); private final Map<Seite, Map<Koordinate, Ergebnis>> schuesse = new EnumMap<>(Seite.class); private Seite amZug; private Seite gewinner;
/** Ein neues Spiel – Spieler 1 ist da, die Phase ist WARTEN_AUF_GEGNER. */ public Spiel() { for (Seite seite : Seite.values()) { schuesse.put(seite, new LinkedHashMap<>()); // in der Reihenfolge der Schüsse } }
/** Spieler 2 tritt bei, die Phase wird AUFSTELLEN. */ public void gegnerTrittBei() { pruefePhase(Phase.WARTEN_AUF_GEGNER, "Das Spiel hat schon zwei Spieler"); phase = Phase.AUFSTELLEN; }
/** * 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) { pruefePhase(Phase.AUFSTELLEN, "Aufstellen geht gerade nicht"); if (flotten.containsKey(seite)) { throw new IllegalStateException("Die Flotte ist schon aufgestellt"); } flotten.put(seite, flotte); if (flotten.size() == 2) { phase = Phase.LAEUFT; amZug = Seite.EINS; } }
/** * 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) { pruefePhase(Phase.LAEUFT, "Das Spiel läuft nicht"); if (seite != amZug) { throw new IllegalStateException("Du bist nicht dran"); } Flotte gegner = flotten.get(seite.gegner()); Ergebnis ergebnis = gegner.beschiesse(ziel); // wirft, wenn schon beschossen schuesse.get(seite).put(ziel, ergebnis);
if (gegner.istVersenkt()) { phase = Phase.VORBEI; gewinner = seite; amZug = null; } else { amZug = seite.gegner(); } return ergebnis; }
public Phase getPhase() { return phase; }
/** Wer gerade schießen darf – leer, solange das Spiel nicht läuft. */ public Optional<Seite> amZug() { return Optional.ofNullable(amZug); }
/** Die Schüsse, die eine Seite abgegeben hat, mit ihren Ergebnissen. */ public Map<Koordinate, Ergebnis> schuesseVon(Seite seite) { return Collections.unmodifiableMap(schuesse.get(seite)); }
/** Wer gewonnen hat – leer, solange das Spiel nicht vorbei ist. */ public Optional<Seite> gewinner() { return Optional.ofNullable(gewinner); }
private void pruefePhase(Phase erwartet, String meldung) { if (phase != erwartet) { throw new IllegalStateException(meldung + " (Phase " + phase + ")"); } }
}Lösung
package de.drv.schiffe.spiel;
import java.util.EnumSet;import java.util.HashSet;import java.util.List;import java.util.Set;
/** * Die Flotte eines Spielers auf seinem Feld. Sie prüft beim Aufstellen alle Regeln und * beantwortet die Schüsse des Gegners. */public class Flotte {
private final List<Schiff> schiffe; private final Set<Koordinate> beschossen = new HashSet<>();
/** * Stellt die Flotte auf. * * @throws IllegalArgumentException wenn nicht jeder {@link Schiffstyp} genau einmal dabei ist * oder sich zwei Schiffe überschneiden */ public Flotte(List<Schiff> schiffe) { Set<Schiffstyp> typen = EnumSet.noneOf(Schiffstyp.class); Set<Koordinate> belegt = new HashSet<>(); for (Schiff schiff : schiffe) { if (!typen.add(schiff.getTyp())) { throw new IllegalArgumentException(schiff.getTyp() + " ist doppelt"); } for (Koordinate feld : schiff.getFelder()) { if (!belegt.add(feld)) { throw new IllegalArgumentException("Zwei Schiffe überschneiden sich auf " + feld); } } } if (typen.size() != Schiffstyp.values().length) { Set<Schiffstyp> fehlen = EnumSet.allOf(Schiffstyp.class); fehlen.removeAll(typen); throw new IllegalArgumentException("Es fehlen: " + fehlen); } this.schiffe = List.copyOf(schiffe); }
/** * Beantwortet einen Schuss auf dieses Feld. * * @throws IllegalStateException wenn auf dieses Kästchen schon geschossen wurde */ public Ergebnis beschiesse(Koordinate ziel) { if (!beschossen.add(ziel)) { throw new IllegalStateException("Auf " + ziel + " wurde schon geschossen"); } for (Schiff schiff : schiffe) { if (schiff.belegt(ziel)) { schiff.triff(ziel); return schiff.istVersenkt() ? Ergebnis.VERSENKT : Ergebnis.TREFFER; } } return Ergebnis.WASSER; }
/** Ob alle Schiffe versenkt sind. */ public boolean istVersenkt() { for (Schiff schiff : schiffe) { if (!schiff.istVersenkt()) { return false; } } return true; }
}Lösung
package de.drv.schiffe.spiel;
import java.util.ArrayList;import java.util.HashSet;import java.util.List;import java.util.Set;
/** Ein aufgestelltes Schiff: sein Typ, seine Kästchen und welche davon getroffen sind. */public class Schiff {
private final Schiffstyp typ; private final List<Koordinate> felder = new ArrayList<>(); private final Set<Koordinate> treffer = new HashSet<>();
/** * Ein Schiff dieses Typs, das bei {@code anfang} beginnt und in {@code richtung} liegt. * * @throws IllegalArgumentException wenn es über den Rand hinausragt */ public Schiff(Schiffstyp typ, Koordinate anfang, Richtung richtung) { this.typ = typ; for (int i = 0; i < typ.getLaenge(); i++) { try { felder.add(anfang.verschoben(richtung, i)); } catch (IllegalArgumentException e) { throw new IllegalArgumentException(typ + " ab " + anfang + " ragt über den Rand"); } } }
public Schiffstyp getTyp() { return typ; }
/** Alle Kästchen, die das Schiff belegt – so viele, wie es lang ist. */ public List<Koordinate> getFelder() { return List.copyOf(felder); }
/** Ob das Schiff dieses Kästchen belegt. */ public boolean belegt(Koordinate feld) { return felder.contains(feld); }
/** Vermerkt einen Treffer auf diesem Kästchen. */ public void triff(Koordinate feld) { if (belegt(feld)) { treffer.add(feld); } }
/** Ob alle Kästchen getroffen sind. */ public boolean istVersenkt() { return treffer.size() == felder.size(); }
}