Zahlenraten 6: Ein entfernter Spielleiter
Jetzt zahlt sich das Interface aus Teil 2 aus. Die Konsole kennt nur einen
Spielleiter. Wenn es einen Spielleiter gibt, der jede Frage über das Netz an
den Server weiterreicht, spielt die Konsole über das Netz – und merkt es nicht.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- einen Client mit dem
HttpClientaus dem JDK und Jackson schreiben - ein Interface so erfüllen, dass die Arbeit woanders passiert
- Statuscodes zurück in die Exceptions des Vertrags übersetzen
- erklären, warum sich an der Konsole nichts ändern musste
Demo-Code: zahlenraten-6
⤓ zahlenraten-6.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 zahlenraten-6 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, JsonServerTest.java, LokalerSpielleiterTest.java, SpielTest.java, Antwort.java, EntfernterSpielleiter.java, Fehler.java, GemeinerSpielleiter.java, Hinweis.java, JsonServer.java, Konsole.java, LokalerSpielleiter.java, ServerStart.java, Spiel.java, SpielNichtGefunden.java, Spielleiter.java, Spielstart.java, Start.java, Versuch.java
Der Starter enthält die Lösung von Teil 5 und zwei Neuigkeiten: den
EntfernterSpielleiter – halb fertig – und eine Start-Klasse, die drei
Spielleiter kennt.
Das Bild
Abschnitt betitelt „Das Bild“ Programm 1 Programm 2┌───────────────────────────┐ ┌───────────────────────────┐│ Konsole │ │ JsonServer ││ │ rate("3f2b…", 50) │ │ │ rate("3f2b…", 50) ││ ▼ │ POST …/versuche│ ▼ ││ EntfernterSpielleiter ────┼────────────────▶│ LokalerSpielleiter ││ ▲ │ {"zahl":50} │ │ ││ │ Antwort(ZU_KLEIN, 1) │◀────────────────┼───┘ ││ │ {"hinweis":…} │ │└───────────────────────────┘ └───────────────────────────┘Für die Konsole ist rate ein Methodenaufruf wie immer. Dass dazwischen ein Netz
liegt, weiß nur der EntfernterSpielleiter. Man nennt so etwas einen
Stellvertreter (englisch Proxy): Er sieht aus wie der echte Spielleiter und
reicht jede Frage weiter.
Der entfernte Spielleiter
Abschnitt betitelt „Der entfernte Spielleiter“package de.drv.zahlenraten;
import tools.jackson.databind.json.JsonMapper;
import java.io.IOException;import java.io.UncheckedIOException;import java.net.URI;import java.net.http.HttpClient;import java.net.http.HttpRequest;import java.net.http.HttpResponse;
/** * Ein Spielleiter, der in Wahrheit auf einem Server sitzt: Jeder Aufruf wird zu einer * HTTP-Anfrage, jede Antwort zurück zu einem Record – und jeder Fehlercode wieder zu der * Exception, die der Vertrag {@link Spielleiter} verspricht. Die Konsole merkt davon nichts. * * <p>Fertig: {@link #neuesSpiel()} und die Werkzeuge. Übung: {@link #rate(String, int)}. */public class EntfernterSpielleiter implements Spielleiter {
private final String server; private final HttpClient client = HttpClient.newHttpClient(); private final JsonMapper json = JsonMapper.builder().build();
/** @param server z. B. "http://localhost:8080" */ public EntfernterSpielleiter(String server) { this.server = server; }
@Override public Spielstart neuesSpiel() { String antwort = sende("/spiele", null); return json.readValue(antwort, Spielstart.class); }
@Override public Antwort rate(String spielId, int zahl) { throw new UnsupportedOperationException("Übung, Stufe 1"); }
// ----- Werkzeuge ---------------------------------------------------------------------
/** Schickt ein POST mit der Nachricht als JSON (oder ohne Rumpf) und liefert die Antwort. */ String sende(String pfad, Object nachricht) { HttpRequest.BodyPublisher rumpf = nachricht == null ? HttpRequest.BodyPublishers.noBody() : HttpRequest.BodyPublishers.ofByteArray(json.writeValueAsBytes(nachricht)); HttpRequest anfrage = HttpRequest.newBuilder(URI.create(server + pfad)) .POST(rumpf) .header("Content-Type", "application/json") .build(); try { HttpResponse<String> antwort = client.send(anfrage, HttpResponse.BodyHandlers.ofString()); pruefe(antwort); return antwort.body(); } catch (IOException e) { throw new UncheckedIOException("Server nicht erreichbar: " + server, e); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new IllegalStateException("Unterbrochen", e); } }
/** Übersetzt einen Fehlercode zurück in die Exception, die der Vertrag verspricht. */ void pruefe(HttpResponse<String> antwort) { int status = antwort.statusCode(); if (status < 400) { return; } String meldung = json.readValue(antwort.body(), Fehler.class).fehler(); switch (status) { case 400 -> throw new IllegalArgumentException(meldung); case 404 -> throw new SpielNichtGefunden(meldung); case 409 -> throw new IllegalStateException(meldung); default -> throw new IllegalStateException("Fehler im Server (" + status + "): " + meldung); } }
}sendeerledigt eine Anfrage: Pfad und Nachricht hinein, Rumpf der Antwort heraus. Die Nachricht wird mit Jackson zu JSON. Ohne Nachricht geht ein leerer Rumpf hinaus.neuesSpielist fertig:POST /spieleschicken, die Antwort alsSpielstartlesen.- Eine
IOException– der Server ist nicht erreichbar – steht nicht im Vertrag.sendeverpackt sie in eine ungeprüfteUncheckedIOException.
pruefe ist der Rückweg für Fehler. Ein Statuscode ab 400 wird wieder zu der
Exception, die der Vertrag verspricht:
| Statuscode | Exception |
|---|---|
400 |
IllegalArgumentException |
404 |
SpielNichtGefunden |
409 |
IllegalStateException |
| alles andere | IllegalStateException mit dem Code in der Meldung |
Die Meldung kommt dabei aus dem {"fehler":"…"} des Servers. Deshalb zeigt
die Konsole über das Netz dieselben Texte wie lokal.
Drei Spielleiter, eine Konsole
Abschnitt betitelt „Drei Spielleiter, eine Konsole“package de.drv.zahlenraten;
import java.util.Scanner;
/** * Hier wird das Programm zusammengesteckt – die Konsole ist immer dieselbe: * <ul> * <li>ohne Argument: ein lokaler Spielleiter im selben Programm</li> * <li>{@code gemein}: der schummelnde Spielleiter</li> * <li>{@code http://…}: ein Spielleiter auf einem Server</li> * </ul> */public class Start {
public static void main(String[] args) { String wahl = args.length > 0 ? args[0] : ""; Spielleiter spielleiter; if (wahl.startsWith("http")) { spielleiter = new EntfernterSpielleiter(wahl); } else if (wahl.equals("gemein")) { spielleiter = new GemeinerSpielleiter(); } else { spielleiter = new LokalerSpielleiter(); } try (Scanner scanner = new Scanner(System.in)) { new Konsole(spielleiter, scanner).spiele(); } }
}Das Argument entscheidet, welcher Spielleiter es wird. Die Konsole ist
dieselbe Datei wie in Teil 3.
Übung: Über das Netz spielen
Abschnitt betitelt „Übung: Über das Netz spielen“Arbeite im Demo-Projekt zahlenraten-6. Du brauchst zwei laufende Programme:
ServerStart und Start mit dem Argument http://localhost:8080 (in IntelliJ
unter Run → Edit Configurations → Program arguments). Beide laufen nebeneinander
– jedes mit seinem eigenen Reiter im Fenster Run.
-
Raten: Setze
rateum. Es ist fast dasselbe wieneuesSpiel: Pfad mit der ID, einVersuchals Nachricht, eineAntwortzurück. Spiele dann eine Runde – und schau dabei in die Ausgabe des Servers. -
Fehler über das Netz: Tippe
abc,0und500ein. Woher kommen die Meldungen, die du siehst? Stoppe dann den Server und rate weiter. Was passiert – und wäre es besser, wenn die Konsole das abfängt? -
Rechner gegen Rechner: Starte den Server auf deinem Rechner und lass deinen Nachbarn mit
Start http://<deine-IP>:8080gegen ihn spielen. Deine IP-Adresse zeigtipconfig(Windows) oderip addr(Linux). Mit dem Argumentgemeinbeim Server spielt dein Nachbar gegen den Schummler – ohne es zu merken. -
Für Schnelle – derselbe Test für alle: Schreibe
EntfernterSpielleiterTest. Er startet einenJsonServerauf Port0und spielt mitLokalerSpielleiterTest.halbieregegen einenEntfernterSpielleiter. Die Hilfsmethode aus Teil 3 funktioniert unverändert – sie kennt ja auch nur denSpielleiter. Prüfe auch, dass die drei Fehler als die richtigen Exceptions zurückkommen.
Lösung
Gegen einen Server mit dem gemeinen Spielleiter, mit Halbieren:
Ich denke mir eine Zahl von 1 bis 100. Rate!Dein Tipp: abcBitte eine Zahl eingeben.Dein Tipp: 0Nur Zahlen von 1 bis 100: 0Dein Tipp: 50Zu klein.Dein Tipp: 75Zu klein.Dein Tipp: 88Zu klein.Dein Tipp: 94Zu klein.Dein Tipp: 97Zu klein.Dein Tipp: 99Zu klein.Dein Tipp: 100Richtig! Du hast 7 Versuche gebraucht.Zu Stufe 2: Bitte eine Zahl eingeben kommt von der Konsole selbst – abc
erreicht den Server gar nicht. Nur Zahlen von 1 bis 100: 0 dagegen steht im
Spiel auf dem Server. Sie reist als {"fehler":"…"} zurück, pruefe macht
wieder eine IllegalArgumentException daraus, und die Konsole gibt die Meldung
aus wie immer:
POST /spiele 201POST /spiele/a9d84c44-b65f-429b-bdff-c8f874c3fc76/versuche 400POST /spiele/a9d84c44-b65f-429b-bdff-c8f874c3fc76/versuche 200Ist der Server weg, bricht die Konsole mit einer UncheckedIOException ab. Die
Konsole könnte sie abfangen – aber dann wüsste sie etwas vom Netz. Besser fängt
sie Start ab und meldet Server nicht erreichbar.
package de.drv.zahlenraten;
import tools.jackson.databind.json.JsonMapper;
import java.io.IOException;import java.io.UncheckedIOException;import java.net.URI;import java.net.http.HttpClient;import java.net.http.HttpRequest;import java.net.http.HttpResponse;
/** * Ein Spielleiter, der in Wahrheit auf einem Server sitzt: Jeder Aufruf wird zu einer * HTTP-Anfrage, jede Antwort zurück zu einem Record – und jeder Fehlercode wieder zu der * Exception, die der Vertrag {@link Spielleiter} verspricht. Die Konsole merkt davon nichts. */public class EntfernterSpielleiter implements Spielleiter {
private final String server; private final HttpClient client = HttpClient.newHttpClient(); private final JsonMapper json = JsonMapper.builder().build();
/** @param server z. B. "http://localhost:8080" */ public EntfernterSpielleiter(String server) { this.server = server; }
@Override public Spielstart neuesSpiel() { String antwort = sende("/spiele", null); return json.readValue(antwort, Spielstart.class); }
@Override public Antwort rate(String spielId, int zahl) { String antwort = sende("/spiele/" + spielId + "/versuche", new Versuch(zahl)); return json.readValue(antwort, Antwort.class); }
// ----- Werkzeuge ---------------------------------------------------------------------
/** Schickt ein POST mit der Nachricht als JSON (oder ohne Rumpf) und liefert die Antwort. */ String sende(String pfad, Object nachricht) { HttpRequest.BodyPublisher rumpf = nachricht == null ? HttpRequest.BodyPublishers.noBody() : HttpRequest.BodyPublishers.ofByteArray(json.writeValueAsBytes(nachricht)); HttpRequest anfrage = HttpRequest.newBuilder(URI.create(server + pfad)) .POST(rumpf) .header("Content-Type", "application/json") .build(); try { HttpResponse<String> antwort = client.send(anfrage, HttpResponse.BodyHandlers.ofString()); pruefe(antwort); return antwort.body(); } catch (IOException e) { throw new UncheckedIOException("Server nicht erreichbar: " + server, e); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new IllegalStateException("Unterbrochen", e); } }
/** Übersetzt einen Fehlercode zurück in die Exception, die der Vertrag verspricht. */ void pruefe(HttpResponse<String> antwort) { int status = antwort.statusCode(); if (status < 400) { return; } String meldung = json.readValue(antwort.body(), Fehler.class).fehler(); switch (status) { case 400 -> throw new IllegalArgumentException(meldung); case 404 -> throw new SpielNichtGefunden(meldung); case 409 -> throw new IllegalStateException(meldung); default -> throw new IllegalStateException("Fehler im Server (" + status + "): " + meldung); } }
}Lösung
Derselbe Test läuft jetzt gegen drei Spielleiter: den lokalen, den gemeinen und den entfernten. Das ist das Versprechen eines Interface: Wer den Vertrag erfüllt, kann überall eingesetzt werden – auch in Tests.
package de.drv.zahlenraten;
import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.IOException;
import org.junit.jupiter.api.AfterEach;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.DisplayName;import org.junit.jupiter.api.Test;
/** Derselbe Vertrag – über das Netz. Die Tests aus Teil 3 gelten auch hier. */class EntfernterSpielleiterTest {
private JsonServer server; private EntfernterSpielleiter spielleiter;
@BeforeEach void starte() throws IOException { server = new JsonServer(new LokalerSpielleiter(), 0); server.starte(); spielleiter = new EntfernterSpielleiter("http://localhost:" + server.getPort()); }
@AfterEach void stoppe() { server.stoppe(); }
@Test @DisplayName("Halbieren findet die Zahl auch über das Netz in höchstens sieben Versuchen") void halbieren() { for (int i = 0; i < 20; i++) { Antwort antwort = LokalerSpielleiterTest.halbiere(spielleiter, spielleiter.neuesSpiel()); assertEquals(Hinweis.RICHTIG, antwort.hinweis()); assertTrue(antwort.versuche() <= 7); } }
@Test @DisplayName("Fehlercodes werden wieder zu den Exceptions des Vertrags") void fehler() { Spielstart start = spielleiter.neuesSpiel(); assertThrows(IllegalArgumentException.class, () -> spielleiter.rate(start.id(), 0)); assertThrows(SpielNichtGefunden.class, () -> spielleiter.rate("gibt-es-nicht", 50)); LokalerSpielleiterTest.halbiere(spielleiter, start); assertThrows(IllegalStateException.class, () -> spielleiter.rate(start.id(), 50)); }
}