Schiffe versenken: Ein Web-Client
Bisher hat ein Java-Programm mit unserem Server gesprochen. Aber das Protokoll gehört nicht Java: Es ist HTTP mit JSON – und das spricht jeder Browser. In diesem Artikel bekommt das Spiel eine Webseite: Felder zum Anklicken, Farben für Treffer und Wasser, und das alles gegen denselben Server, ohne eine Zeile am Protokoll zu ändern.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- erklären, warum ein Protokoll einen Client in einer anderen Sprache erlaubt
- einen
HttpServerDateien wie HTML, CSS und JavaScript ausliefern lassen - die JavaScript-Seite eines Clients lesen:
fetch,async/await, Polling, Änderungen an der Seite - die Anfragen eines Web-Clients in den Entwicklerwerkzeugen des Browsers beobachten
Demo-Code: 39-schiffe-web
⤓ schiffe-web.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 39-schiffe-web 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, StatischeDateien.java, Ergebnis.java, Flotte.java, Koordinate.java, Phase.java, Richtung.java, Schiff.java, Schiffstyp.java, Seite.java, Spiel.java, index.html, spiel.js, stil.css, HttpSpieldienstTest.java, KonsoleTest.java, SpielServerTest.java, FlotteTest.java, KoordinateTest.java, SpielTest.java
Das Demo-Projekt ist das fertige Spiel aus Spieldienst und Zusammenspiel – mit einer neuen Klasse im Server und drei Dateien für die Webseite.
Was neu ist
Abschnitt betitelt „Was neu ist“Browser SpielServer │ GET / ─────────────────▶ StatischeDateien ─▶ web/index.html │ GET /spiel.js, /stil.css ───────────────▶ StatischeDateien ─▶ web/spiel.js, web/stil.css │ │ POST /spiele, GET /spiele/{id}, … ─────▶ bearbeite (wie bisher) ─▶ Spieldienst| Teil | neu oder geändert |
|---|---|
server/StatischeDateien |
neu: liefert Dateien aus src/main/resources/web aus |
server/SpielServer |
eine neue Zeile in starte() |
src/main/resources/web/ |
neu: index.html, spiel.js, stil.css |
| Kern, Dienst, Protokoll, Java-Client | unverändert |
Der Server liefert die Seite aus
Abschnitt betitelt „Der Server liefert die Seite aus“package de.drv.schiffe.server;
import com.sun.net.httpserver.HttpExchange;import com.sun.net.httpserver.HttpHandler;
import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.nio.charset.StandardCharsets;import java.util.Map;
/** * Liefert Dateien aus einem Ordner im Classpath aus – die Webseite des Spiels. In einem * Maven-Projekt liegt dieser Ordner unter {@code src/main/resources}. */public class StatischeDateien implements HttpHandler {
private static final Map<String, String> TYPEN = Map.of( "html", "text/html; charset=utf-8", "css", "text/css; charset=utf-8", "js", "text/javascript; charset=utf-8", "svg", "image/svg+xml");
private final String ordner;
/** @param ordner z. B. "web" für src/main/resources/web */ public StatischeDateien(String ordner) { this.ordner = ordner; }
@Override public void handle(HttpExchange anfrage) throws IOException { try { String pfad = anfrage.getRequestURI().getPath(); if (pfad.equals("/")) { pfad = "/index.html"; } // Nur GET – und keine Wege aus dem Ordner hinaus if (!anfrage.getRequestMethod().equals("GET") || pfad.contains("..")) { sende(anfrage, 404, "text/plain; charset=utf-8", "Nicht gefunden".getBytes(StandardCharsets.UTF_8)); return; } try (InputStream datei = getClass().getResourceAsStream("/" + ordner + pfad)) { if (datei == null) { sende(anfrage, 404, "text/plain; charset=utf-8", "Nicht gefunden".getBytes(StandardCharsets.UTF_8)); return; } String endung = pfad.substring(pfad.lastIndexOf('.') + 1); sende(anfrage, 200, TYPEN.getOrDefault(endung, "application/octet-stream"), datei.readAllBytes()); } } catch (Exception e) { e.printStackTrace(); // sonst verschluckt der HttpServer die Exception anfrage.close(); } }
private static void sende(HttpExchange anfrage, int status, String typ, byte[] inhalt) throws IOException { anfrage.getResponseHeaders().set("Content-Type", typ); anfrage.sendResponseHeaders(status, inhalt.length); try (OutputStream aus = anfrage.getResponseBody()) { aus.write(inhalt); } System.out.printf("%-4s %-40s %d%n", anfrage.getRequestMethod(), anfrage.getRequestURI(), status); }
}- Die Dateien liegen unter
src/main/resources/web. Maven kopiert sie beim Übersetzen nachtarget/classes/web– auf den Classpath. Dort findetgetClass().getResourceAsStream("/web/index.html")sie, egal von wo das Programm gestartet wird. Dasselbe haben wir mit den.properties-Dateien im Kapitel Lokalisierung gesehen. - Der Content-Type sagt dem Browser, was er bekommt. Eine HTML-Seite, die als
text/plainankommt, zeigt er als Text an. pfad.contains("..")verhindert, dass jemand mit/../…Dateien außerhalb des Ordners abruft.- Das
tryum alles ist die Lehre aus dem Server-Artikel: Eine Exception im Handler würde sonst spurlos verschwinden.
Und im SpielServer:
server.createContext(Protokoll.SPIELE, this::bearbeite);server.createContext("/", new StatischeDateien("web")); // alles andere: die WebseiteDer HttpServer wählt für jede Anfrage den Kontext mit dem längsten
passenden Präfix: /spiele/7f3a geht an bearbeite, /spiel.js und / an
StatischeDateien.
Die Webseite
Abschnitt betitelt „Die Webseite“index.html
<!doctype html><html lang="de"><head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1"> <title>Schiffe versenken</title> <link rel="stylesheet" href="stil.css"></head><body> <h1>Schiffe versenken</h1>
<!-- 1. Anmelden --> <section id="anmelden"> <button id="neu">Neues Spiel</button> <span>oder</span> <input id="spiel-id" placeholder="Spiel-ID"> <button id="beitreten">Beitreten</button> </section>
<!-- 2. Aufstellen --> <section id="aufstellen" hidden> <p>Eine Zeile pro Schiff: Typ, Anfangsfeld, Richtung (W oder S).</p> <textarea id="flotte" rows="5" cols="32" spellcheck="false"></textarea> <div> <button id="zufaellig">Zufällig</button> <button id="aufstellen-los">Aufstellen</button> </div> </section>
<!-- 3. Spielen --> <section id="spiel" hidden> <div class="felder"> <div> <h2>Dein Feld</h2> <div id="eigenes-feld" class="feld"></div> </div> <div> <h2>Zielfeld – klicke zum Schießen</h2> <div id="zielfeld" class="feld"></div> </div> </div> </section>
<p id="status">Lege ein Spiel an oder tritt einem bei.</p> <p id="fehler" role="alert"></p>
<script src="spiel.js"></script></body></html>Die Seite hat drei Abschnitte – Anmelden, Aufstellen, Spielen –,
genau wie die Konsole. Je nach Phase ist einer sichtbar, die anderen tragen
hidden. Dazu zwei Zeilen für Status und Fehler.
stil.css
body { font-family: system-ui, sans-serif; margin: 2rem; color: #1f2933;}
section { margin: 1rem 0;}
button { font: inherit; padding: 0.3rem 0.8rem;}
textarea { font-family: ui-monospace, monospace;}
.felder { display: flex; flex-wrap: wrap; gap: 2rem;}
.feld { display: grid; grid-template-columns: repeat(10, 2rem); gap: 2px;}
.feld button { width: 2rem; height: 2rem; padding: 0; border: 1px solid #9fb3c8; background: #e8f1fb; cursor: pointer;}
.feld button:disabled { cursor: default;}
.feld .schiff { background: #829ab1; }.feld .wasser { background: #bcccdc; }.feld .treffer { background: #f0b429; }.feld .versenkt { background: #d64545; }
#status { font-weight: 600;}
#fehler { color: #d64545;}Das CSS ordnet die Kästchen mit display: grid in zehn Spalten und färbt sie:
grau die eigenen Schiffe, hellblau Wasser, gelb Treffer, rot versenkt.
Das JavaScript
Abschnitt betitelt „Das JavaScript“spiel.js
// Der Web-Client: spricht dasselbe Protokoll wie der Java-Client – nur in JavaScript.
const SPALTEN = "ABCDEFGHIJ";const SCHIFFE = { FLUGZEUGTRAEGER: 5, SCHLACHTSCHIFF: 4, KREUZER: 3, U_BOOT: 3, ZERSTOERER: 2 };
let spielId = null; // aus dem Beitrittlet token = null; // für den Header X-Spielerlet eigeneSchiffe = []; // die eigenen Kästchen, z. B. "B2" – kennt nur dieser Clientlet stand = null; // der letzte Spielstand vom Server
// ----- Das Protokoll -------------------------------------------------------------------
/** Eine Anfrage an den Server. Fehlercodes werden zu einer Exception mit der Meldung des Servers. */async function anfrage(methode, pfad, nachricht) { const kopf = { "Content-Type": "application/json" }; if (token) { kopf["X-Spieler"] = token; } const antwort = await fetch(pfad, { method: methode, headers: kopf, body: nachricht ? JSON.stringify(nachricht) : undefined, }); if (!antwort.ok) { const fehler = await antwort.json().catch(() => ({ fehler: antwort.statusText })); throw new Error(fehler.fehler); } return antwort.status === 204 ? null : antwort.json();}
// ----- 1. Anmelden ---------------------------------------------------------------------
document.getElementById("neu").onclick = () => anmelden(() => anfrage("POST", "/spiele"));document.getElementById("beitreten").onclick = () => { const id = document.getElementById("spiel-id").value.trim(); anmelden(() => anfrage("POST", `/spiele/${id}/spieler`));};
async function anmelden(aufruf) { try { const beitritt = await aufruf(); spielId = beitritt.spielId; token = beitritt.token; document.getElementById("anmelden").hidden = true; zeigeFehler(""); setInterval(aktualisiere, 1000); // Polling: jede Sekunde nachfragen aktualisiere(); } catch (e) { zeigeFehler(e.message); }}
// ----- 2. Aufstellen -------------------------------------------------------------------
document.getElementById("zufaellig").onclick = () => { document.getElementById("flotte").value = zufaelligeFlotte().join("\n");};
document.getElementById("aufstellen-los").onclick = async () => { const zeilen = document.getElementById("flotte").value.trim().split("\n"); const schiffe = zeilen.map((zeile) => { const [typ, anfang, richtung] = zeile.trim().toUpperCase().split(/\s+/); return { typ, anfang, richtung: richtung?.startsWith("S") ? "SENKRECHT" : "WAAGERECHT" }; }); try { await anfrage("PUT", `/spiele/${spielId}/flotte`, { schiffe }); eigeneSchiffe = schiffe.flatMap(felderVon); zeigeFehler(""); aktualisiere(); } catch (e) { zeigeFehler(e.message); }};
/** Alle Kästchen eines Schiffs, z. B. ["B2", "C2", "D2"]. */function felderVon(schiff) { const spalte = SPALTEN.indexOf(schiff.anfang[0]); const zeile = Number(schiff.anfang.slice(1)); const felder = []; for (let i = 0; i < SCHIFFE[schiff.typ]; i++) { felder.push(schiff.richtung === "WAAGERECHT" ? SPALTEN[spalte + i] + zeile : SPALTEN[spalte] + (zeile + i)); } return felder;}
/** Fünf Schiffe an zufälligen Stellen, ohne Überschneidung und ohne über den Rand zu ragen. */function zufaelligeFlotte() { const belegt = new Set(); const zeilen = []; for (const [typ, laenge] of Object.entries(SCHIFFE)) { while (true) { const waagerecht = Math.random() < 0.5; const spalte = Math.floor(Math.random() * (waagerecht ? 11 - laenge : 10)); const zeile = 1 + Math.floor(Math.random() * (waagerecht ? 10 : 11 - laenge)); const schiff = { typ, anfang: SPALTEN[spalte] + zeile, richtung: waagerecht ? "WAAGERECHT" : "SENKRECHT" }; const felder = felderVon(schiff); if (felder.every((feld) => !belegt.has(feld))) { felder.forEach((feld) => belegt.add(feld)); zeilen.push(`${typ} ${schiff.anfang} ${waagerecht ? "W" : "S"}`); break; } } } return zeilen;}
// ----- 3. Spielen ----------------------------------------------------------------------
/** Holt den Stand und zeichnet die Seite neu. */async function aktualisiere() { try { stand = await anfrage("GET", `/spiele/${spielId}`); } catch (e) { zeigeFehler(e.message); return; } const aufstellenSichtbar = stand.phase === "AUFSTELLEN" && eigeneSchiffe.length === 0; document.getElementById("aufstellen").hidden = !aufstellenSichtbar; document.getElementById("spiel").hidden = stand.phase !== "LAEUFT" && stand.phase !== "VORBEI"; zeichne("eigenes-feld", stand.gegnerischeSchuesse, false); zeichne("zielfeld", stand.eigeneSchuesse, stand.amZug); zeigeStatus();}
function zeigeStatus() { const text = { WARTEN_AUF_GEGNER: `Warte auf den Gegner – gib ihm die Spiel-ID: ${spielId}`, AUFSTELLEN: eigeneSchiffe.length === 0 ? "Stelle deine Flotte auf." : "Warte, bis der Gegner aufgestellt hat …", LAEUFT: stand.amZug ? "Du bist dran!" : "Der Gegner ist dran …", VORBEI: stand.gewonnen ? "Gewonnen!" : "Verloren.", }; document.getElementById("status").textContent = text[stand.phase];}
/** Zeichnet ein Feld aus 10 × 10 Kästchen. Auf dem Zielfeld kann man klicken, wenn man dran ist. */function zeichne(id, schuesse, klickbar) { const feld = document.getElementById(id); feld.replaceChildren(); for (let zeile = 1; zeile <= 10; zeile++) { for (const spalte of SPALTEN) { const name = spalte + zeile; const kaestchen = document.createElement("button"); kaestchen.title = name; const ergebnis = schuesse[name]; if (ergebnis) { kaestchen.classList.add(ergebnis.toLowerCase()); // wasser, treffer, versenkt } else if (id === "eigenes-feld" && eigeneSchiffe.includes(name)) { kaestchen.classList.add("schiff"); } kaestchen.disabled = !klickbar || ergebnis !== undefined; kaestchen.onclick = () => schiesse(name); feld.append(kaestchen); } }}
async function schiesse(feld) { try { const antwort = await anfrage("POST", `/spiele/${spielId}/schuesse`, { feld }); zeigeFehler(""); document.getElementById("status").textContent = `${feld}: ${antwort.ergebnis}`; aktualisiere(); } catch (e) { zeigeFehler(e.message); }}
function zeigeFehler(text) { document.getElementById("fehler").textContent = text;}
document.getElementById("flotte").value = zufaelligeFlotte().join("\n");Wer den Java-Client kennt, erkennt fast alles wieder:
| im Java-Client | im Web-Client |
|---|---|
HttpSpieldienst.sende und pruefe |
anfrage(methode, pfad, nachricht) |
HttpClient.send(…) |
await fetch(pfad, …) |
Jackson: writeValueAsBytes, readValue |
JSON.stringify(…), await antwort.json() |
| Fehlercode → Exception | if (!antwort.ok) throw new Error(fehler.fehler) |
warteBis(…) mit Thread.sleep |
setInterval(aktualisiere, 1000) |
Feldanzeige.zeichne |
zeichne(id, schuesse, klickbar) – mit Knöpfen statt Zeichen |
Aufstellung.von("KREUZER B2 W") |
die Zeilen des Textfelds mit split(/\s+/) |
Konsole.zufaelligeFlotte() |
zufaelligeFlotte() |
Drei Dinge, die anders sind
Abschnitt betitelt „Drei Dinge, die anders sind“asyncundawait. Eine Anfrage im Browser blockiert nicht – die Seite muss weiter auf Klicks reagieren.fetchliefert sofort ein Versprechen (Promise) auf die Antwort,awaitwartet darauf, ohne die Seite einzufrieren. Eine Funktion mitawaitmussasyncsein.- Ereignisse statt Schleife. Die Konsole hatte eine
while-Schleife: fragen, warten, fragen. Im Browser gibt es keine Schleife, sondern Ereignisse: Ein Klick ruftonclickauf,setIntervalruft jede Sekundeaktualisiereauf. Dazwischen tut die Seite nichts. - Die Seite neu zeichnen.
aktualisiereholt den Stand und baut beide Felder jedes Mal neu: 200 Knöpfe, jeder mit einer Klasse für seine Farbe. Klickbar sind sie nur, wenn man dran ist und das Kästchen noch nicht beschossen hat.
Die eigenen Schiffe kennt nur dieser Client – der Server verrät sie im
Spielstand ja nicht. Deshalb merkt sich eigeneSchiffe beim Aufstellen die
Kästchen, um sie grau zu zeichnen.
Spielen
Abschnitt betitelt „Spielen“-
Starte
ServerStart. -
Öffne im Browser
http://localhost:8080und klicke auf Neues Spiel. Die Seite zeigt die Spiel-ID. -
Öffne einen zweiten Tab mit derselben Adresse, trage die Spiel-ID ein und klicke auf Beitreten.
-
In beiden Tabs auf Aufstellen klicken – das Textfeld ist schon mit einer zufälligen Flotte gefüllt. Dann abwechselnd auf das Zielfeld klicken.
Über das Netz geht es genauso: Wer nicht am Server-Rechner sitzt, öffnet
http://192.168.1.23:8080 – mit der Adresse aus ipconfig.
Und weil beide Clients dasselbe Protokoll sprechen, kann auch einer im
Browser gegen einen an der Konsole spielen: Der eine legt im Browser an, der
andere tritt mit ClientStart und der Spiel-ID bei.
Übung: Die Seite verbessern
Abschnitt betitelt „Übung: Die Seite verbessern“Die Übungen sind JavaScript – kein Java. Nach jeder Änderung genügt es, im
Browser neu zu laden; IntelliJ muss den Server nur neu starten, damit die
geänderten Dateien aus target/classes kommen.
-
Polling beenden: Auch nach Gewonnen! fragt die Seite jede Sekunde weiter nach. Merke dir den Rückgabewert von
setIntervalund beende das Polling mitclearInterval, sobald die PhaseVORBEIist. -
Was hat der Gegner getan? Zeige nach jedem Schuss des Gegners eine Meldung wie Der Gegner hat auf D4 geschossen: WASSER. Tipp: Vergleiche die Schlüssel von
stand.gegnerischeSchuessemit denen der letzten Abfrage. -
Ein Link zum Beitreten: Statt die Spiel-ID abzutippen, soll ein Link wie
http://localhost:8080/?spiel=ca904de1-…direkt beitreten. Zeige den Link nach dem Anlegen an. Tipp:new URLSearchParams(location.search).get("spiel"). -
Für Schnelle – ganz versenkt: Bei einem versenkten Schiff ist nur das letzte Kästchen rot, die anderen bleiben gelb. Warum? Und welche zwei Wege gibt es, das ganze Schiff rot zu färben – einen nur im Client und einen, der das Protokoll ändert?
Lösung
Zu 1 – das Polling in einer Variablen merken:
let poller = null;// in anmelden:poller = setInterval(aktualisiere, 1000);// in aktualisiere, nach dem Holen des Stands:if (stand.phase === "VORBEI") { clearInterval(poller);}Zu 2 – die bekannten Schüsse des Gegners merken und vergleichen:
let bekannteGegnerschuesse = new Set();// in aktualisiere:for (const [feld, ergebnis] of Object.entries(stand.gegnerischeSchuesse)) { if (!bekannteGegnerschuesse.has(feld)) { bekannteGegnerschuesse.add(feld); zeigeFehler(""); // alte Fehlermeldung weg document.getElementById("status").textContent = `Der Gegner hat auf ${feld} geschossen: ${ergebnis}`; }}Zu 3 – beim Laden der Seite nachsehen, ob ein Spiel im Link steht:
const ausDemLink = new URLSearchParams(location.search).get("spiel");if (ausDemLink) { anmelden(() => anfrage("POST", `/spiele/${ausDemLink}/spieler`));}// nach dem Anlegen:const link = `${location.origin}/?spiel=${spielId}`;Zu 4 – der Server meldet VERSENKT nur für den Schuss, der das Schiff
versenkt hat; welche anderen Kästchen dazugehören, sagt das Protokoll nicht.
- Nur im Client: Von dem roten Kästchen aus in alle vier Richtungen gehen, solange gelbe Kästchen folgen – sie gehören zum selben Schiff, denn Schiffe liegen gerade. Das klappt fast immer, kann sich aber irren, wenn zwei Schiffe nebeneinander liegen.
- Mit dem Protokoll: Die
SchussAntwortbekommt ein zusätzliches Feld, etwa"versenkteFelder": ["B2", "C2", "D2"]. Das ist eine Erweiterung: Ein alter Client, der das Feld nicht kennt, liest einfach darüber hinweg – der im Browser ohnehin, der Java-Client auch, denn Jackson 3 überspringt unbekannte Felder. (Jackson 2 dagegen würde in seiner Voreinstellung mit einer Exception abbrechen – ein Grund, bei einer Bibliothek genau hinzusehen.) Server und Kern müssen dafür wissen, welche Kästchen das versenkte Schiff hatte – also ändert sich diesmal auch etwas außerhalb des Clients.