Zum Inhalt springen

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.

  • einen Client mit dem HttpClient aus 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 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 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.

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.

EntfernterSpielleiter.java
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);
}
}
}
  • sende erledigt eine Anfrage: Pfad und Nachricht hinein, Rumpf der Antwort heraus. Die Nachricht wird mit Jackson zu JSON. Ohne Nachricht geht ein leerer Rumpf hinaus.
  • neuesSpiel ist fertig: POST /spiele schicken, die Antwort als Spielstart lesen.
  • Eine IOException – der Server ist nicht erreichbar – steht nicht im Vertrag. sende verpackt sie in eine ungeprüfte UncheckedIOException.

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.

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

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.

  1. Raten: Setze rate um. Es ist fast dasselbe wie neuesSpiel: Pfad mit der ID, ein Versuch als Nachricht, eine Antwort zurück. Spiele dann eine Runde – und schau dabei in die Ausgabe des Servers.

  2. Fehler über das Netz: Tippe abc, 0 und 500 ein. 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?

  3. Rechner gegen Rechner: Starte den Server auf deinem Rechner und lass deinen Nachbarn mit Start http://<deine-IP>:8080 gegen ihn spielen. Deine IP-Adresse zeigt ipconfig (Windows) oder ip addr (Linux). Mit dem Argument gemein beim Server spielt dein Nachbar gegen den Schummler – ohne es zu merken.

  4. Für Schnelle – derselbe Test für alle: Schreibe EntfernterSpielleiterTest. Er startet einen JsonServer auf Port 0 und spielt mit LokalerSpielleiterTest.halbiere gegen einen EntfernterSpielleiter. Die Hilfsmethode aus Teil 3 funktioniert unverändert – sie kennt ja auch nur den Spielleiter. Prüfe auch, dass die drei Fehler als die richtigen Exceptions zurückkommen.

Lösung

Gegen einen Server mit dem gemeinen Spielleiter, mit Halbieren:

Terminal-Fenster
Ich denke mir eine Zahl von 1 bis 100. Rate!
Dein Tipp: abc
Bitte eine Zahl eingeben.
Dein Tipp: 0
Nur Zahlen von 1 bis 100: 0
Dein Tipp: 50
Zu klein.
Dein Tipp: 75
Zu klein.
Dein Tipp: 88
Zu klein.
Dein Tipp: 94
Zu klein.
Dein Tipp: 97
Zu klein.
Dein Tipp: 99
Zu klein.
Dein Tipp: 100
Richtig! 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:

Terminal-Fenster
POST /spiele 201
POST /spiele/a9d84c44-b65f-429b-bdff-c8f874c3fc76/versuche 400
POST /spiele/a9d84c44-b65f-429b-bdff-c8f874c3fc76/versuche 200

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

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

EntfernterSpielleiterTest.java
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));
}
}