Zum Inhalt springen

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.

  • erklären, warum ein Protokoll einen Client in einer anderen Sprache erlaubt
  • einen HttpServer Dateien 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 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 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.

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
StatischeDateien.java
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 nach target/classes/web – auf den Classpath. Dort findet getClass().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/plain ankommt, zeigt er als Text an.
  • pfad.contains("..") verhindert, dass jemand mit /../… Dateien außerhalb des Ordners abruft.
  • Das try um alles ist die Lehre aus dem Server-Artikel: Eine Exception im Handler würde sonst spurlos verschwinden.

Und im SpielServer:

SpielServer.java (Ausschnitt)
server.createContext(Protokoll.SPIELE, this::bearbeite);
server.createContext("/", new StatischeDateien("web")); // alles andere: die Webseite

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

index.html
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
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.

spiel.js
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 Beitritt
let token = null; // für den Header X-Spieler
let eigeneSchiffe = []; // die eigenen Kästchen, z. B. "B2" – kennt nur dieser Client
let 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()
  • async und await. Eine Anfrage im Browser blockiert nicht – die Seite muss weiter auf Klicks reagieren. fetch liefert sofort ein Versprechen (Promise) auf die Antwort, await wartet darauf, ohne die Seite einzufrieren. Eine Funktion mit await muss async sein.
  • Ereignisse statt Schleife. Die Konsole hatte eine while-Schleife: fragen, warten, fragen. Im Browser gibt es keine Schleife, sondern Ereignisse: Ein Klick ruft onclick auf, setInterval ruft jede Sekunde aktualisiere auf. Dazwischen tut die Seite nichts.
  • Die Seite neu zeichnen. aktualisiere holt 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.

  1. Starte ServerStart.

  2. Öffne im Browser http://localhost:8080 und klicke auf Neues Spiel. Die Seite zeigt die Spiel-ID.

  3. Öffne einen zweiten Tab mit derselben Adresse, trage die Spiel-ID ein und klicke auf Beitreten.

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

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.

  1. Polling beenden: Auch nach Gewonnen! fragt die Seite jede Sekunde weiter nach. Merke dir den Rückgabewert von setInterval und beende das Polling mit clearInterval, sobald die Phase VORBEI ist.

  2. 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.gegnerischeSchuesse mit denen der letzten Abfrage.

  3. 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").

  4. 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 SchussAntwort bekommt 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.