Skip to content

12. Webprogrammierung

Voraussetzungen: Version 8 der [Tax]-Anwendung, die am Ende dieses Kapitels beschrieben wird, verwendet die Module [tax-dao], [tax-business] und [tax-ui] aus Version 5 (Kapitel 6) wieder. Bevor Sie Ihre Projekte erstellen oder öffnen, müssen Sie Version 5 mit dem Befehl [mvn install] im Ordner [06-architectures/TaxV5] im lokalen Maven-Repository installiert haben (siehe Kapitel 6, Abschnitt zu [mvn install]).

12.1. Allgemeine Informationen

12.1.1. Internetprotokolle

Hier stellen wir die Kommunikationsprotokolle des Internets vor, auch bekannt als TCP/IP-Protokollfamilie (Transmission Control Protocol / Internet Protocol), benannt nach den beiden wichtigsten Protokollen. Es ist hilfreich, wenn der Leser vor der Entwicklung verteilter Anwendungen ein allgemeines Verständnis der Funktionsweise von Netzwerken – insbesondere der TCP/IP-Protokolle – besitzt. Diese Darstellung beruht auf einem Text aus dem Administrationshandbuch „Lan Workplace for DOS“ von Novell (frühe 1990er Jahre), dessen Struktur und Geist sie beibehält und zugleich aktualisiert: Das Internet von 2026 ist nicht mehr ganz dasselbe wie das von 1990.

Das allgemeine Konzept, ein Netzwerk aus heterogenen Computern zu schaffen, geht auf Forschungen der DARPA (Defense Advanced Research Projects Agency) in den Vereinigten Staaten zurück. Die DARPA entwickelte die als TCP/IP bekannte Protokollfamilie, die es heterogenen Maschinen ermöglicht, miteinander zu kommunizieren. Diese Protokolle wurden in einem Netzwerk namens ARPAnet getestet, das später zum Internet wurde (ARPAnet führte TCP/IP am 1. Januar 1983 ein). Die TCP/IP-Protokolle definieren Formate und Regeln für Senden und Empfangen, die von der Netzwerkarchitektur und der verwendeten Hardware unabhängig sind.

Das von der DARPA entworfene und von den TCP/IP-Protokollen verwaltete Netzwerk ist ein paketvermitteltes Netzwerk. Ein solches Netzwerk überträgt Informationen in kleinen Stücken, den Paketen. Sendet ein Computer also eine große Datei, wird sie in kleine Stücke zerlegt, die über das Netzwerk gesendet und am Ziel wieder zusammengesetzt werden. TCP/IP legt das Format dieser Pakete fest, das insbesondere Folgendes enthält:

  • die Quelle des Pakets;
  • sein Ziel;
  • seine Länge;
  • sein Typ.

Die Internetprotokolle sind in öffentlichen Dokumenten beschrieben, den RFC (Request for Comments), die von der IETF (Internet Engineering Task Force) veröffentlicht werden und unter www.rfc-editor.org verfügbar sind. Einige dieser Dokumente werden wir im Verlauf dieses Kapitels zitieren.

12.1.2. Das OSI-Modell

Die TCP/IP-Protokolle folgen im Großen und Ganzen dem offenen Netzwerkmodell namens OSI (Open Systems Interconnection Reference Model), das von der ISO (International Organization for Standardization) definiert wurde. Dieses Modell beschreibt ein ideales Netzwerk, in dem sich die Kommunikation zwischen Maschinen durch ein Sieben-Schichten-Modell darstellen lässt:

Image

Jede Schicht erhält Dienste von der darunterliegenden Schicht und stellt der darüberliegenden Schicht ihre eigenen Dienste zur Verfügung. Angenommen, zwei Anwendungen auf verschiedenen Maschinen A und B wollen miteinander kommunizieren: Sie tun das auf der Anwendungsschicht. Sie müssen nicht alle Einzelheiten der Funktionsweise des Netzwerks kennen: Jede Anwendung gibt die Informationen, die sie übertragen möchte, an die darunterliegende Schicht weiter, die Darstellungsschicht. Die Anwendung muss daher nur die Regeln für die Schnittstelle zur Darstellungsschicht kennen. Sobald sich die Informationen in der Darstellungsschicht befinden, werden sie nach weiteren Regeln an die Sitzungsschicht weitergereicht und so fort, bis die Informationen das physische Medium erreichen und physisch zur Zielmaschine übertragen werden. Dort durchlaufen sie den umgekehrten Prozess wie auf der sendenden Maschine.

Auf jeder Schicht sendet der sendende Prozess, der für das Senden der Informationen zuständig ist, diese an einen empfangenden Prozess auf der anderen Maschine, der zur selben Schicht gehört. Er tut dies nach bestimmten Regeln, die als Protokoll der Schicht bezeichnet werden. Die eigentliche Kommunikation läuft durch die Schichten von Maschine A nach unten, überquert das physische Netzwerk und läuft dann durch die Schichten von Maschine B nach oben; jede Schicht nimmt jedoch wahr, dass sie direkt mit der entsprechenden Schicht auf der anderen Maschine kommuniziert.

Die Rollen der einzelnen Schichten sind wie folgt:

Schicht
Rolle
Bitübertragungsschicht (Physical)
Sorgt für die Übertragung von Bits über ein physisches Medium (Kupferkabel, Glasfaserkabel, Funkwellen). Wichtige Aspekte auf dieser Ebene sind die Kodierung der Informationen in Signale und das Übertragungsverfahren.
Sicherungsschicht (Data Link)
Abstrahiert die physischen Eigenschaften der Bitübertragungsschicht. Teilt die Informationen in Frames auf, erkennt (und korrigiert teilweise) Übertragungsfehler und regelt den Zugriff auf das gemeinsam genutzte Medium.
Vermittlungsschicht (Network)
Verwaltet den Weg, den die über das Netzwerk gesendeten Informationen nehmen müssen. Man nennt das Routing: die Bestimmung der Route, die die Informationen bis zu ihrem Ziel nehmen müssen.
Transportschicht (Transport)
Ermöglicht die Kommunikation zwischen zwei Anwendungen, während die vorherigen Schichten nur die Kommunikation zwischen Maschinen erlaubten. Ein von dieser Schicht erbrachter Dienst ist das Multiplexing: Die Transportschicht nutzt eine einzige Netzwerkverbindung (von Maschine zu Maschine), um Daten zu übertragen, die zu mehreren Anwendungen gehören.
Sitzungsschicht (Session)
Stellt Dienste bereit, mit denen eine Anwendung eine Arbeitssitzung auf einer entfernten Maschine öffnen und aufrechterhalten kann.
Darstellungsschicht (Presentation)
Vereinheitlicht die Darstellung von Daten über verschiedene Maschinen hinweg. Die Daten von Maschine A werden von der Darstellungsschicht der Maschine A nach einem Standardformat „formatiert“, bevor sie über das Netzwerk gesendet werden. Sobald sie die Darstellungsschicht der Zielmaschine B erreichen – die sie an ihrem Standardformat erkennt –, werden die Daten so umformatiert, dass die Anwendung auf Maschine B sie erkennen kann.
Anwendungsschicht (Application)
Auf dieser Ebene befinden sich Anwendungen, die in der Regel nah am Benutzer sind, wie E-Mail, das Web oder die Dateiübertragung.

12.1.3. Das TCP/IP-Modell

Das OSI-Modell ist ein Referenzmodell, das nie unverändert implementiert wurde. Die TCP/IP-Protokollfamilie, die zum Standard geworden ist, ist in nur vier Schichten organisiert:

Image

Die Sitzungs- und die Darstellungsschicht existieren in TCP/IP als solche nicht: Ihre Funktionen werden, wenn nötig, von den Anwendungen selbst oder von Zwischenprotokollen wie TLS (Verschlüsselung des Datenaustauschs) übernommen, das zwischen TCP und die Anwendung eingefügt wird.

Die Netzzugangsschicht

In lokalen Netzwerken ist die heute vorherrschende Technologie Ethernet für kabelgebundene und Wi-Fi (IEEE-802.11-Standards) für drahtlose Verbindungen. Andere Technologien wie Token Ring sind inzwischen verschwunden.

Ethernet ist der Name einer Technologie für paketvermittelte lokale Netzwerke, die Anfang der 1970er Jahre bei Xerox erfunden und 1980 von Xerox, Intel und Digital Equipment sowie später vom IEEE (Standard 802.3) standardisiert wurde. Das ursprüngliche Ethernet bestand aus einem Koaxialkabel, an das alle Maschinen angeschlossen waren (Bustopologie), mit einer Datenrate von 10 Megabit pro Sekunde:

Image

Es war ein Broadcast-Netzwerk: Eine sendende Maschine schickte Informationen mit der Adresse der empfangenden Maschine über das Kabel; alle angeschlossenen Maschinen empfingen sie, und nur der vorgesehene Empfänger behielt sie. Da mehrere Maschinen gleichzeitig senden konnten, mussten Kollisionen erkannt werden: Das war das Zugriffsverfahren CSMA/CD (Carrier Sense Multiple Access / Collision Detect). Jeder Sender hörte vor dem Senden das Kabel ab (CSMA) und überprüfte während des Sendens, ob das, was über das Kabel lief, tatsächlich das war, was er gesendet hatte; war das nicht der Fall, lag eine Kollision vor (CD): Alle beendeten das Senden und versuchten es nach einer zufälligen Wartezeit erneut.

Das moderne Ethernet hat sich stark weiterentwickelt: Die Geräte sind über Twisted-Pair-Kabel oder Glasfaserkabel an einen Switch angeschlossen, der jeden Frame an den spezifischen Port des Empfängers weiterleitet. Die Verbindungen sind vollduplex (gleichzeitiges Senden und Empfangen): Es gibt keine Kollisionen mehr, und CSMA/CD ist obsolet geworden. Typische Datenraten liegen zwischen 1 und 10 Gigabit pro Sekunde, in Rechenzentren deutlich höher.

Unverändert geblieben ist die 48-Bit-Adressierung: Jede Netzwerkkarte hat eine Adresse, die physische Adresse oder MAC-Adresse (Media Access Control) genannt wird und im Allgemeinen als sechs hexadezimale Bytes geschrieben wird (zum Beispiel [00:1A:2B:3C:4D:5E]). Sie wird vom Hersteller in die Karte programmiert, kann aber – entgegen langjähriger Behauptungen – per Software geändert werden: Moderne Betriebssysteme verwenden in Wi-Fi-Netzwerken sogar zufällige MAC-Adressen, um zu verhindern, dass ein Gerät von Netzwerk zu Netzwerk verfolgt werden kann.

Die Internetschicht (Vermittlungsschicht)

Auf dieser Schicht finden wir die folgenden Protokolle:

Protokoll
Rolle
IP (Internet Protocol)
liefert Pakete zwischen zwei Netzwerkknoten, in Version 4 (IPv4) oder 6 (IPv6)
ICMP (Internet Control Message Protocol)
erleichtert die Kommunikation zwischen dem Programm des IP-Protokolls auf einer Maschine und dem auf einer anderen Maschine. Es ist somit ein Protokoll zum Austausch von Kontrollnachrichten innerhalb des IP-Protokolls selbst
ARP (Address Resolution Protocol)
ordnet die IP-Adresse einer Maschine der physischen Adresse der Maschine zu (in IPv6 übernimmt diese Rolle das NDP-Protokoll, das Neighbor Discovery Protocol)

Manchmal wird auch RARP (Reverse Address Resolution Protocol) erwähnt, das die umgekehrte Zuordnung vornahm. Es ist seit Langem zugunsten von DHCP veraltet, auf das wir später eingehen.

Die Transportschicht

Diese Schicht umfasst die folgenden Protokolle:

Protokoll
Rolle
TCP (Transmission Control Protocol)
gewährleistet die zuverlässige und geordnete Zustellung von Informationen zwischen zwei Anwendungen
UDP (User Datagram Protocol)
liefert Informationen zwischen zwei Anwendungen ohne Zuverlässigkeitsgarantie

Das Protokoll QUIC (2021), auf dem HTTP/3 basiert, ist ein zuverlässiges, verschlüsseltes Transportprotokoll auf Basis von UDP.

Die Anwendungsschicht

Hier finden wir verschiedene Protokolle, die wir etwas später näher erläutern:

Protokoll
Rolle
HTTP, HTTPS (HyperText Transfer Protocol)
Das Protokoll des Webs: Ein Client (Browser, Anwendung) fordert Ressourcen von einem Webserver an. HTTPS ist mit TLS verschlüsseltes HTTP
DNS (Domain Name System)
wandelt einen Hostnamen in eine IP-Adresse um
SMTP (Simple Mail Transfer Protocol)
ermöglicht das Senden von E-Mails
POP3, IMAP
ermöglichen das Lesen von auf einem Server gespeicherten E-Mails
SSH (Secure Shell)
ermöglicht es, sich mit einer entfernten Maschine zu verbinden und dort Befehle verschlüsselt auszuführen. Es hat TELNET ersetzt, das dieselbe Funktion ohne Verschlüsselung erfüllte
FTP (File Transfer Protocol), SFTP
ermöglichen Dateiübertragungen
DHCP (Dynamic Host Configuration Protocol)
ermöglicht es einer Maschine, automatisch ihre IP-Adresse und Netzwerkkonfiguration zu erhalten

12.1.4. Funktionsweise der Internetprotokolle

Anwendungen, die in der TCP/IP-Umgebung entwickelt werden, nutzen in der Regel mehrere Protokolle dieser Umgebung. Ein Anwendungsprogramm kommuniziert mit der höchsten Schicht der Protokolle. Diese Schicht reicht die Informationen an die darunterliegende Schicht weiter und so fort, bis das physische Medium erreicht ist. Dort werden die Informationen physisch zur empfangenden Maschine übertragen, wo sie dieselben Schichten erneut durchlaufen – diesmal in umgekehrter Richtung –, bis sie die Anwendung erreichen, für die die gesendeten Informationen bestimmt sind. Das folgende Diagramm zeigt den Weg der Informationen:

Image

Nehmen wir ein Beispiel: eine Anwendung, die mit TCP eine Datei an eine andere Maschine sendet.

  • Die Anwendung übergibt der Transportschicht eine zu übertragende Folge von Bytes;
  • die Transportschicht teilt diese Folge von Bytes in TCP-Segmente auf und stellt jedem Segment einen Header voran, der unter anderem die Portnummern von Quelle und Ziel sowie eine Sequenznummer enthält. Die Segmente werden an die Netzwerkschicht weitergereicht, die vom IP-Protokoll gesteuert wird;
  • die IP-Schicht erstellt ein Paket, das das empfangene TCP-Segment kapselt. In den Header dieses Pakets trägt sie die IP-Adressen der Quell- und der Zielmaschine ein. Sie bestimmt außerdem die physische Adresse der Maschine, an die das Paket zugestellt werden soll (das Ziel selbst oder ein Router). Das gesamte Paket wird an die Netzzugangsschicht weitergegeben, also an die Netzwerkkarte, die die Maschine mit dem physischen Netzwerk verbindet;
  • dort wird das IP-Paket seinerseits in einen physischen Frame gekapselt und über das Medium an seinen Empfänger gesendet;
  • Auf der Zielmaschine führt die Netzzugangsschicht den umgekehrten Vorgang aus: Sie entkapselt das IP-Paket aus dem physischen Frame und gibt es an die IP-Schicht weiter;
  • die IP-Schicht prüft, ob das Paket gültig ist: Sie berechnet eine Prüfsumme seines Headers, die sie im Header des Pakets wiederfinden muss. Ist das nicht der Fall, wird das Paket verworfen;
  • wird das Paket als gültig erachtet, entkapselt die IP-Schicht das darin enthaltene TCP-Segment und reicht es an die Transportschicht weiter;
  • die TCP-Schicht prüft ebenfalls eine Prüfsumme des Segments. Ist sie korrekt, sendet sie der Quellmaschine eine Bestätigung; andernfalls wird das Segment ignoriert (und von der Quelle erneut gesendet);
  • Anhand der Sequenznummern bringt die TCP-Schicht die Segmente in die richtige Reihenfolge;
  • die TCP-Schicht muss nur noch den Datenteil der Segmente an die Zielanwendung übergeben, die anhand der Zielportnummer identifiziert wird.

12.1.5. Adressierungsfragen im Internet

Ein Netzwerkknoten kann ein Computer, ein Drucker, ein Telefon, ein vernetztes Gerät sein – tatsächlich alles, was über die TCP/IP-Protokolle kommunizieren kann. Jeder Knoten hat eine physische Adresse, deren Format vom Netzwerktyp abhängt. In einem Ethernet- oder Wi-Fi-Netzwerk wird die physische Adresse mit 6 Bytes kodiert.

Die Internetadresse (IP) eines Knotens ist eine logische Adresse: Sie ist unabhängig von der Hardware und dem verwendeten Netzwerk. In IPv4 ist es eine 4-Byte-Adresse, die sowohl ein Netzwerk als auch einen Knoten in diesem Netzwerk identifiziert. Sie wird üblicherweise als vier Zahlen – die Werte der vier Bytes – dargestellt, die durch einen Punkt getrennt sind. So lautete die Adresse der Maschine namens „Lagaffe“ an der Fakultät für Naturwissenschaften in Angers lange 193.49.144.1 und die der Maschine namens „Liny“ 193.49.144.9. Daraus ließ sich ableiten, dass die Adresse des lokalen Netzwerks 193.49.144.0 war und dass es in diesem Netzwerk bis zu 254 Knoten geben konnte.

Da IP-Adressen vom physischen Netzwerk unabhängig sind, kann eine Maschine in Netzwerk A mit einer Maschine in Netzwerk B kommunizieren, ohne sich um den Netzwerktyp der letzteren zu kümmern: Sie muss lediglich ihre IP-Adresse kennen. Das IP-Protokoll in jedem Netzwerk übernimmt die Umwandlung zwischen IP-Adressen und physischen Adressen in beiden Richtungen.

Alle öffentlichen IP-Adressen müssen eindeutig sein. Ihre Vergabe folgt einer hierarchischen Struktur: Die IANA (Internet Assigned Numbers Authority) verteilt Adressblöcke an fünf regionale Registries, darunter RIPE NCC für Europa, die sie an Betreiber und große Organisationen weiterverteilen. Diese weisen sie dann ihren Kunden zu. Der Administrator eines Netzwerks, das den Block 193.49.144.0 bis 193.49.144.255 erhalten hat, kann die Adressen 193.49.144.1 bis 193.49.144.254 nach eigenem Ermessen vergeben. In Frankreich war lange das INRIA für die Vergabe von Adressen zuständig; das ist schon seit geraumer Zeit nicht mehr der Fall.

12.1.5.1. Die IP-Adressklassen und die CIDR-Notation

Eine IPv4-Adresse ist eine Folge von 4 Bytes, notiert als I1.I2.I3.I4, die tatsächlich zwei Informationen enthält:

  • die Netzwerkadresse (die höherwertigen Bits);
  • die Adresse eines Knotens innerhalb dieses Netzwerks (die niederwertigen Bits).

Ursprünglich wurde die Größe dieser beiden Felder durch den Wert des ersten Bytes bestimmt. IP-Adressen wurden in drei Hauptklassen eingeteilt:

Klasse
Erstes Byte
Netzwerk / Knoten
Anzahl der Netzwerke und Knoten
A
1 bis 126 (höchstwertiges Bit 0)
R1.N1.N2.N3: 1 Byte Netzwerk (7 signifikante Bits), 3 Byte Knoten
126 Netzwerke mit je 2²⁴ - 2 Knoten (ca. 16 Millionen)
B
128 bis 191 (höchstwertige 10 Bits)
R1.R2.N1.N2: 2 Byte Netzwerk (14 signifikante Bits), 2 Byte Knoten
2¹⁴ = 16.384 Netzwerke mit je 2¹⁶ - 2 = 65.534 Knoten
C
192 bis 223 (höchstwertige 110 Bits)
R1.R2.R3.N1: 3 Byte Netzwerk (21 signifikante Bits), 1 Byte Knoten
2²¹ Netzwerke (ca. 2 Millionen) mit je 254 Knoten

Da die Adresse der Maschine Lagaffe 193.49.144.1 lautet, ist das höchstwertige Byte 193, binär 11000001: Das Netzwerk war ein Netzwerk der Klasse C.

Diese Klasseneinteilung erwies sich als viel zu starr: Eine Organisation mit 300 Maschinen musste ein Netzwerk der Klasse B verwenden und verschwendete dabei mehr als 65.000 Adressen. Seit 1993 (RFC 1518 und 1519) wurden die Klassen zugunsten des klassenlosen Routings (CIDR, Classless Inter-Domain Routing) aufgegeben. Die Grenze zwischen Netzwerkanteil und Hostanteil kann an jedem beliebigen Bit gesetzt werden; sie wird durch die Länge des Netzwerkpräfixes nach einem Schrägstrich angegeben:

  • 193.49.144.0/24: Die ersten 24 Bits bezeichnen das Netzwerk, die letzten 8 Bits den Knoten. Dieses Netzwerk umfasst die Adressen 193.49.144.0 bis 193.49.144.255;
  • 10.0.0.0/8: ein Netzwerk mit 2²⁴ Adressen;
  • 192.168.1.0/26: ein Netzwerk mit 2⁶ = 64 Adressen, von 192.168.1.0 bis 192.168.1.63.

Die alte Schreibweise für die Subnetzmaske ist weiterhin gebräuchlich und drückt dasselbe aus: Das Präfix /24 entspricht der Maske 255.255.255.0. Die Begriffe „Klasse A, B, C“ sind weiterhin üblich, entsprechen aber keinem tatsächlichen Mechanismus mehr.

12.1.5.2. Reservierte Adressen, private Adressen und NAT

Bestimmte Adressen haben einen besonderen Zweck:

  • Eine Adresse, deren Hostanteil ausschließlich aus Nullen besteht, bezeichnet das Netzwerk selbst: 193.49.144.0 ist die Adresse des Netzwerks 193.49.144.0/24;
  • eine Adresse, deren Hostanteil ausschließlich aus Einsen besteht, ist eine Broadcast-Adresse: 193.49.144.255 bezeichnet alle Hosts des Netzwerks 193.49.144.0/24. Diese beiden Adressen können daher keinem Knoten zugewiesen werden: Ein /24-Netzwerk mit 256 Adressen bietet nur 254 nutzbare Adressen;
  • die Adressen 127.0.0.0/8, in der Praxis 127.0.0.1, sind Loopback-Adressen: Eine Maschine verwendet sie, um sich selbst anzusprechen, ohne das Netzwerk zu durchlaufen. Der Name [localhost] ist ihnen zugeordnet;
  • die Blöcke 10.0.0.0/8, 172.16.0.0/12 und 192.168.0.0/16 (RFC 1918) sind für private Netzwerke reserviert: Sie können innerhalb eines Unternehmens oder eines Haushalts frei verwendet werden, werden im Internet aber nicht geroutet;
  • die Blöcke 192.0.2.0/24, 198.51.100.0/24 und 203.0.113.0/24 (RFC 5737) sind für Dokumentation und Beispiele reserviert.

Die Anzahl der IPv4-Adressen (2³², also etwas mehr als 4 Milliarden) reicht für alle vernetzten Maschinen nicht aus. Der zentrale Adressvorrat der IANA war 2011 erschöpft, der von RIPE NCC 2019. Der Mangel wurde durch Network Address Translation (NAT) umgangen: Die Geräte eines Haushalts haben private Adressen (etwa 192.168.1.x), und der Router, der sie mit dem Internet verbindet, „übersetzt“ sie in seine eigene, eindeutige öffentliche Adresse. Die langfristige Lösung ist IPv6.

12.1.5.3. Die IPv6-Adressen

IPv6 (RFC 2460 im Jahr 1998, heute RFC 8200) kodiert Adressen mit 128 Bits und bietet damit 2¹²⁸ mögliche Adressen – etwa 3,4 × 10³⁸ –, sodass ein Mangel nicht mehr zu befürchten ist. Eine IPv6-Adresse wird als acht durch Doppelpunkte getrennte Gruppen aus je vier Hexadezimalziffern geschrieben:

2001:0db8:0000:0000:8a2e:0000:0370:7334

Führende Nullen jeder Gruppe können weggelassen werden, und eine einzelne Folge von Nullgruppen kann durch [::] ersetzt werden. Die vorstehende Adresse wird daher als [2001:db8::8a2e:0:370:7334] geschrieben. Die Loopback-Adresse, das Äquivalent zu 127.0.0.1, lautet [::1]. In einer URL wird die IPv6-Adresse in eckige Klammern gesetzt, um ihre Doppelpunkte nicht mit dem Doppelpunkt vor der Portnummer zu verwechseln: [http://[::1]:8080/].

IPv6 bringt weitere Vereinfachungen: Der Paket-Header hat eine feste Länge, die automatische Adresskonfiguration ist standardmäßig integriert, und die Adressübersetzung per NAT ist nicht mehr nötig. Die Verbreitung verlief langsam, doch ein erheblicher und wachsender Teil des Internetverkehrs läuft inzwischen über IPv6 (Google veröffentlicht beispielsweise den Anteil seiner Nutzer, die per IPv6 darauf zugreifen), und die großen französischen Internetanbieter stellen es ihren Kunden bereit. Beide Versionen existieren nebeneinander: Die meisten Maschinen haben sowohl IPv4- als auch IPv6-Adressen (man spricht von „Dual Stack“), und Programme müssen beide verarbeiten können.

12.1.5.4. Protokolle zur Adressumsetzung: IP ↔ physische Adresse

Wir haben gesehen, dass Daten bei der Übertragung von einer Maschine zur anderen beim Durchlaufen der IP-Schicht in Pakete gekapselt werden. Diese Pakete haben folgende Form:

Image

Das IP-Paket enthält also die IP-Adressen der Quell- und der Zielmaschine. Wenn dieses Paket an die Schicht übergeben wird, die für den Versand über das physische Netzwerk zuständig ist, werden ihm zusätzliche Informationen hinzugefügt, die den physischen Frame bilden, der schließlich über das Netzwerk gesendet wird. Das Format eines Frames in einem Ethernet-Netzwerk ist zum Beispiel wie folgt:

Image

Die ersten 8 Bytes (Präambel) dienen der Synchronisierung; das 2 Byte lange Feld vor den Daten gibt in der gebräuchlichsten Form des Ethernet-Frames den Typ des transportierten Protokolls an (IPv4, IPv6, ARP …) und nicht die Länge des Pakets. Im fertigen Frame befinden sich die physischen Adressen der Quell- und der Zielmaschine (im tatsächlichen Frame steht die Zieladresse vor der Quelladresse, anders als in der Abbildung dargestellt). Wie werden sie ermittelt?

Die sendende Maschine ermittelt die physische Adresse der Maschine, mit der sie kommunizieren möchte, anhand von deren IP-Adresse mithilfe des Protokolls ARP (Address Resolution Protocol):

  • Sie sendet ein spezielles Paket, ein sogenanntes ARP-Paket, das die IP-Adresse der Maschine enthält, deren physische Adresse gesucht wird. Es enthält außerdem ihre eigene IP-Adresse sowie ihre physische Adresse;
  • dieses Paket wird an alle Knoten des lokalen Netzwerks gesendet (Broadcast);
  • diese Knoten erkennen die besondere Art des Pakets. Der Knoten, der seine IP-Adresse im Paket wiedererkennt, antwortet, indem er dem Absender seine physische Adresse sendet. Das kann er tun, weil er die IP-Adresse und die physische Adresse des Absenders im Paket gefunden hat;
  • der Absender erhält somit die gesuchte physische Adresse. Er speichert sie in einem Cache, um sie später verwenden zu können, falls weitere Pakete an denselben Empfänger gesendet werden müssen.

Bei IPv6 wird derselbe Dienst vom Protokoll NDP (Neighbor Discovery Protocol) erbracht, das auf ICMPv6-Nachrichten beruht.

Es bleibt die Frage: Woher kennt eine Maschine ihre eigene IP-Adresse? Sie kann in eine Konfigurationsdatei der Maschine eingetragen werden – bei Servern ist das nach wie vor üblich. Muss ein Administrator jedoch das Netzwerk umgestalten, ist es mühsam und fehleranfällig, die Konfigurationsdateien aller Maschinen einzeln zu ändern. Das Protokoll RARP erlaubte es einer Maschine früher, ihre IP-Adresse anhand ihrer physischen Adresse bei einem Server zu erfragen. Es wurde durch DHCP (Dynamic Host Configuration Protocol, RFC 2131) ersetzt: Beim Start sendet die Maschine eine Anfrage per Broadcast ins Netzwerk; ein Server (etwa ein Heimrouter oder ein dedizierter Server in einem Unternehmen) weist ihr für begrenzte Zeit eine Adresse zu (eine Lease) und liefert den Rest ihrer Konfiguration mit: Netzwerkpräfix, Routeradresse und Adressen der DNS-Server. Der Administrator muss dann nur noch den DHCP-Server konfigurieren. Bei IPv6 kann eine Maschine ihre Adresse außerdem selbst aus dem vom Router angekündigten Präfix bilden (Autokonfiguration per SLAAC).

12.1.6. Die Netzwerkschicht des Internets, die sogenannte IP-Schicht

Das IP-Protokoll legt das Format fest, das Pakete haben müssen, und wie sie beim Senden und Empfangen zu behandeln sind. Diese besondere Art von Paket heißt IP-Datagramm. Wir haben es bereits besprochen:

Image

Wichtig ist, dass das IP-Datagramm neben den zu übertragenden Daten die IP-Adressen der Quell- und der Zielmaschine enthält. So weiß die Zielmaschine, wer ihr eine Nachricht sendet.

Anders als ein Netzwerk-Frame, dessen Länge durch die physischen Eigenschaften des durchlaufenen Netzwerks bestimmt wird, wird die Länge des IP-Datagramms von der Software festgelegt und ist daher in verschiedenen physischen Netzwerken gleich. Wir haben gesehen, dass das IP-Datagramm beim Übergang von der Netzwerkschicht zur physischen Schicht in einen physischen Frame gekapselt wird.

Physische Frames wandern von Knoten zu Knoten in Richtung ihres Ziels, das sich nicht unbedingt im selben physischen Netzwerk wie die sendende Maschine befindet. Das IP-Paket kann daher nacheinander in verschiedene physische Frames gekapselt werden, und zwar an den Knoten, die zwei Netzwerke unterschiedlichen Typs verbinden. Es ist auch möglich, dass das IP-Paket zu groß ist, um in einen physischen Frame gekapselt zu werden (die Nutzlast eines Ethernet-Frames ist auf 1.500 Bytes begrenzt). Bei IPv4 zerlegt der Knoten, an dem dieses Problem auftritt, das IP-Paket in Fragmente, die erst am endgültigen Ziel wieder zusammengesetzt werden. Bei IPv6 fragmentieren Router Pakete nicht mehr: Der Sender muss die maximal akzeptierte Größe entlang des Pfades ermitteln und die Größe seiner Pakete entsprechend anpassen.

12.1.6.1. Routing

Routing ist das Verfahren, IP-Pakete zu ihrem Ziel zu leiten. Es gibt zwei Verfahren: direktes Routing und indirektes Routing.

Direktes Routing

Direktes Routing bezeichnet die Übertragung eines IP-Pakets direkt vom Sender zum Empfänger innerhalb desselben Netzwerks:

  • Die Maschine, die ein IP-Datagramm sendet, kennt die IP-Adresse des Empfängers;
  • sie ermittelt die physische Adresse des Empfängers über das Protokoll ARP oder aus ihrem Cache, falls diese Adresse bereits ermittelt wurde;
  • sie sendet das Paket über das Netzwerk an diese physische Adresse.

Indirektes Routing

Indirektes Routing bezeichnet die Übertragung eines IP-Pakets an ein Ziel, das sich in einem anderen Netzwerk befindet als dem, zu dem der Sender gehört. In diesem Fall sind die „Netzwerk“-Anteile der IP-Adressen von Quell- und Zielmaschine verschieden; die Quellmaschine erkennt das, indem sie die Zieladresse mit ihrem eigenen Netzwerkpräfix vergleicht. Sie sendet das Paket dann an einen besonderen Knoten, einen Router, der das lokale Netzwerk mit anderen Netzwerken verbindet und dessen IP-Adresse der Quellmaschine bekannt ist (man spricht vom Standardgateway; es wird meist per DHCP bereitgestellt). Ein Router ist mit mindestens zwei Netzwerken verbunden und hat in jedem von ihnen eine IP-Adresse:

Image

In unserem obigen Beispiel gilt:

  • Netzwerk Nr. 1 hat die Adresse 193.49.144.0/24 und Netzwerk Nr. 2 die Adresse 193.49.145.0/24;
  • in Netzwerk Nr. 1 hat der Router die Adresse 193.49.144.6, in Netzwerk Nr. 2 die Adresse 193.49.145.3.

Die Aufgabe des Routers besteht darin, das IP-Paket, das er – enthalten in einem physischen Frame aus Netzwerk Nr. 1 – empfängt, in einen physischen Frame zu legen, der über Netzwerk Nr. 2 übertragen werden kann. Liegt die Ziel-IP-Adresse des Pakets in Netzwerk Nr. 2, sendet der Router das Paket direkt dorthin; andernfalls sendet er es an einen anderen Router, der Netzwerk Nr. 2 mit Netzwerk Nr. 3 verbindet, und so weiter. Die Router des Internets tauschen ständig Informationen über die Netzwerke aus, die sie erreichen können (Routing-Protokolle wie BGP zwischen Betreibern), um ihre Routing-Tabellen aufzubauen.

12.1.6.2. Fehler- und Kontrollnachrichten

Ebenfalls in der Netzwerkschicht – und damit auf derselben Ebene wie das IP-Protokoll – befindet sich das Protokoll ICMP (Internet Control Message Protocol). Es dient dazu, Nachrichten über die internen Vorgänge im Netzwerk zu senden: Knoten nicht erreichbar, Paket hat zu viele Router durchlaufen usw. ICMP-Nachrichten werden in IP-Pakete gekapselt und über das Netzwerk gesendet. Die IP-Schichten der verschiedenen Knoten ergreifen anhand der empfangenen ICMP-Nachrichten die geeigneten Maßnahmen. Eine Anwendung bekommt diese netzwerkspezifischen Probleme daher selbst nie zu sehen. Die Befehle [ping] (die ICMP-Nachrichten „Echo Request“ senden und auf „Echo Reply“ warten) und [traceroute] / [tracert] (der die durchlaufenen Router anzeigt) beruhen auf ICMP.

12.1.7. Die Transportschicht: die Protokolle UDP und TCP

12.1.7.1. Das Protokoll UDP: User Datagram Protocol

Das Protokoll UDP ermöglicht einen unzuverlässigen Datenaustausch zwischen zwei Punkten; das bedeutet, dass weder die erfolgreiche Zustellung eines Pakets an sein Ziel noch die Reihenfolge, in der Pakete eintreffen, garantiert ist. Die Anwendung kann sich, wenn sie möchte, selbst darum kümmern – zum Beispiel, indem sie nach dem Senden einer Nachricht eine Bestätigung abwartet, bevor sie die nächste sendet.

Bisher haben wir auf Netzwerkebene von Maschinenadressen wie IP gesprochen. Auf einer einzelnen Maschine können jedoch gleichzeitig verschiedene Prozesse nebeneinander laufen, und alle können miteinander kommunizieren. Beim Senden einer Nachricht müssen Sie daher nicht nur die IP-Adresse der Zielmaschine angeben, sondern auch den „Namen“ des Zielprozesses. Dieser Name ist in Wirklichkeit eine 16-Bit-Zahl (von 1 bis 65.535), die Portnummer genannt wird. Bestimmte Nummern sind für Standardanwendungen reserviert: Port 53 für DNS, 80 für HTTP, 443 für HTTPS, 25 für SMTP und so weiter. Ports unterhalb von 1024 heißen „Well-known Ports“; unter Linux sind besondere Berechtigungen erforderlich, um einen Dienst auf einem von ihnen zu starten. Die Beispiele in diesem Kapitel verwenden Ports in den Bereichen 27100–27199 und 27200–27299.

Die vom Protokoll UDP verarbeiteten Pakete heißen Datagramme. Sie haben folgende Form:

Image

Diese Datagramme werden in IP-Pakete und anschließend in physische Frames gekapselt. UDP wird verwendet, wenn Geschwindigkeit wichtiger ist als Zuverlässigkeit oder wenn die Anwendung Verluste selbst behandelt: DNS (eine Frage, eine Antwort), Live-Audio- und Videostreaming, Online-Spiele und das Protokoll QUIC von HTTP/3.

12.1.7.2. Das Protokoll TCP: Transmission Control Protocol

Für sichere Kommunikation reicht das Protokoll UDP nicht aus: Der Anwendungsentwickler muss selbst ein Protokoll schaffen, um zu prüfen, dass die Pakete korrekt zugestellt werden. Das Protokoll TCP vermeidet diese Probleme. Seine Merkmale sind die folgenden:

  • Der Prozess, der Daten übertragen möchte, baut zunächst eine Verbindung zu dem Prozess auf, der die Informationen empfangen soll. Diese Verbindung wird zwischen einem Port der sendenden Maschine und einem Port der empfangenden Maschine durch den Austausch von drei Segmenten (SYN, SYN-ACK, ACK: der „Three-Way-Handshake“) aufgebaut. Damit entsteht zwischen den beiden Ports ein virtueller Kanal, der ausschließlich den beiden Prozessen vorbehalten ist, die die Verbindung aufgebaut haben;
  • alle vom Quellprozess übertragenen Bytes kommen in der Reihenfolge an ihrem Ziel an, in der sie gesendet wurden, was beim Protokoll UDP nicht garantiert ist, da Pakete unterschiedliche Wege nehmen können;
  • Die übertragenen Informationen erscheinen kontinuierlich: Es handelt sich um einen Bytestrom. Der sendende Prozess überträgt Informationen in seinem eigenen Tempo. Diese Informationen werden nicht zwangsläufig sofort gesendet: Das Protokoll TCP kann warten, bis es genügend Daten zum Senden hat. Sie werden in eine Struktur namens TCP-Segment gelegt. Ist dieses Segment gefüllt, wird es an die IP-Schicht übergeben, wo es in ein IP-Paket gekapselt wird. Eine wichtige Konsequenz für den Programmierer: Eine „Zeile“, die auf einmal gesendet wird, kann in mehreren Teilen ankommen, und mehrere Zeilen können gemeinsam ankommen. Die Anwendung muss selbst die Grenzen ihrer Nachrichten erkennen (wir verwenden dafür das Zeilenende-Zeichen);
  • Jedes vom Protokoll TCP gesendete Segment wird nummeriert. Das empfangende TCP prüft, ob es die Segmente der Reihe nach erhält. Für jedes korrekt empfangene Segment sendet es dem Absender eine Bestätigung;
  • wenn das TCP, das ein Segment gesendet hat, nach einer gewissen Zeit keine Bestätigung erhält, sendet es das betreffende Segment erneut und gewährleistet so die Qualität des Informationsübertragungsdienstes;
  • Der zwischen den beiden kommunizierenden Prozessen aufgebaute virtuelle Kanal ist Vollduplex: Informationen können gleichzeitig in beide Richtungen fließen. So kann der Zielprozess Bestätigungen senden, auch während der Quellprozess weiter Informationen sendet. Das erlaubt es dem TCP der Quelle zum Beispiel, mehrere Segmente zu senden, ohne auf Bestätigungen zu warten. Stellt es nach einer gewissen Zeit fest, dass es für ein bestimmtes Segment Nr. n keine Bestätigung erhalten hat, setzt es das Senden der Segmente ab diesem Punkt fort;
  • TCP regelt außerdem seine Datenrate, um den Empfänger (Flusskontrolle) oder das Netzwerk (Überlastkontrolle) nicht zu überlasten.

12.1.8. Die Anwendungsschicht

Oberhalb der Protokolle UDP und TCP befinden sich verschiedene Standardprotokolle:

TELNET und SSH

TELNET ermöglicht es einem Benutzer auf Maschine A, sich mit Maschine B (oft Host genannt) zu verbinden, als hätte er ein an diese Maschine angeschlossenes Terminal. TELNET beruht auf TCP. Seine Datenaustausche, einschließlich der Passwörter, werden im Klartext übertragen: Es wurde durch SSH (Secure Shell) ersetzt, das denselben Dienst verschlüsselt bereitstellt und außerdem für die sichere Dateiübertragung (SFTP, SCP) und zum Aufbau von Tunneln verwendet wird. Das Client-Programm [telnet] war lange ein praktisches Werkzeug, um „von Hand“ mit einem TCP-Server zu kommunizieren: Wir werden sehen, wie Sie es ersetzen können.

FTP (File Transfer Protocol)

Dieses Protokoll ermöglicht den Austausch von Dateien zwischen zwei entfernten Maschinen sowie Dateioperationen wie das Anlegen von Verzeichnissen. Es beruht auf dem Protokoll TCP. Wie TELNET überträgt es Passwörter im Klartext; es wird zugunsten von SFTP und HTTPS verdrängt.

TFTP (Trivial File Transfer Protocol)

Dieses Protokoll ist eine vereinfachte Variante von FTP. Es beruht auf dem Protokoll UDP. Es wird nach wie vor verwendet, um Maschinen über das Netzwerk zu booten.

DNS (Domain Name System)

Wenn ein Benutzer Informationen mit einer entfernten Maschine austauschen möchte, muss er deren IP-Adresse kennen. Es ist viel bequemer, eine Maschine mit einem Namen anzusprechen als mit ihrer IP-Adresse. Daraus ergibt sich das Problem der Eindeutigkeit der Namen: Es gibt Milliarden miteinander verbundener Maschinen. Man könnte sich eine zentrale Instanz vorstellen, die die Namen vergibt, doch das wäre sehr schwerfällig. Die Kontrolle über die Namen wurde auf Domänen verteilt. Jede Domäne wird von einer Organisation verwaltet, die bei der Wahl der Namen innerhalb ihrer Domäne völlig frei ist. So gehören Maschinen in Frankreich häufig zur Domäne [fr], die von der AFNIC verwaltet wird (bis zur Gründung der AFNIC im Jahr 1997 verwaltete das INRIA sie). Um die Sache weiter zu vereinfachen, ist die Kontrolle noch weiter dezentralisiert: Innerhalb der Domäne [fr] werden Domänen angelegt. Beispielsweise besitzt die Universität Angers die Domäne [univ-angers.fr]; die Abteilung, die sie verwaltet, kann die Rechner im Netzwerk der Universität völlig frei benennen und Subdomänen anlegen.

Der vollständige Name einer Maschine (FQDN, Fully Qualified Domain Name) gibt die Hierarchie der Domänen an, zu denen sie gehört, vom Spezifischsten zum Allgemeinsten: [www.univ-angers.fr]. Innerhalb einer Domäne können oft relative Namen verwendet werden, die vom System automatisch vervollständigt werden.

Eine Anwendung kann eine Maschine also über ihren Namen ansprechen. Letztlich benötigen Sie aber trotzdem die IP-Adresse dieser Maschine. Angenommen, Maschine A möchte mit Maschine B kommunizieren:

  • Maschine A prüft zunächst eine lokale Zuordnungsdatei ([/etc/hosts] unter Linux und macOS, [C:\Windows\System32\drivers\etc\hosts] unter Windows) und dann ihren Cache;
  • andernfalls fragt sie den DNS-Server ab, dessen Adresse in ihrer Konfiguration steht (meist per DHCP bereitgestellt). Sie sendet eine DNS-Anfrage mit dem Namen der gesuchten Maschine. Kennt der befragte Server die Antwort oder hat er sie im Cache, liefert er die zugehörige IP-Adresse an Maschine A zurück. Andernfalls befragt er seinerseits – ausgehend von den Root-Servern – die Server, die für die Domäne [fr] und dann für [univ-angers.fr] zuständig sind, und so weiter, bis er die Antwort erhält, die dann an Maschine A zurückgereicht wird.

Die DNS-Domäne ordnet einem Namen verschiedene Arten von Einträgen zu: A (IPv4-Adresse), AAAA (IPv6-Adresse), CNAME (Alias auf einen anderen Namen), MX (Mailserver der Domäne) usw.

HTTP und HTTPS (HyperText Transfer Protocol)

Dies ist das Web-Protokoll und heute mit Abstand das am häufigsten verwendete: nicht nur von Browsern, sondern auch von Anwendungen, die Daten austauschen (die Webservices, die im nächsten Kapitel behandelt werden). Wir werden es im Detail untersuchen. HTTPS ist HTTP, übertragen über eine mit TLS (Transport Layer Security) verschlüsselte Verbindung; dies ist heute die Standardform des Webs.

SMTP, POP3 und IMAP

SMTP dient zum Senden von E-Mails, während POP3 und IMAP zum Lesen von E-Mails dienen, die auf einem Server gespeichert sind. Auch diese werden wir behandeln.

XDR, RPC, NFS

Schließlich erwähnen wir drei Protokolle, die von Sun Microsystems definiert wurden, dem Unternehmen, das Java geschaffen hat: XDR (eXternal Data Representation), das eine standardisierte, maschinenunabhängige Datendarstellung festlegt; RPC (Remote Procedure Call), ein auf XDR beruhendes Protokoll für entfernte Prozeduraufrufe; NFS (Network File System), das es einer Maschine erlaubt, das Dateisystem einer anderen Maschine zu „sehen“, und auf RPC beruht. NFS wird in der Unix-Welt weiterhin verwendet. Das Konzept entfernter Prozeduraufrufe wurde von vielen Nachfolgern übernommen; heute gehören dazu die Webservices REST (auf Basis von HTTP) und gRPC (auf Basis von HTTP/2).

12.1.9. Fazit

In dieser Einführung haben wir einige der wichtigsten Merkmale der Internetprotokolle vorgestellt. Um dieses Gebiet gründlicher zu erkunden, können Leser das Standardwerk von Douglas Comer, *Internetworking with TCP/IP, Volume 1 ” (Pearson, 6. Auflage), heranziehen – frühere Auflagen davon wurden ins Französische übersetzt – sowie die in diesem Kapitel zitierten RFC. Für HTTP ist die Mozilla-Dokumentation unter developer.mozilla.org/en-US/docs/Web/HTTP eine ausgezeichnete Einführung.

12.2. Java-Klassen für die Verwaltung von IP-Adressen

Eine Maschine im Internet wird durch eine IP-Adresse identifiziert, die zwei Formen annehmen kann:

  • IPv4: in 32 Bits kodiert und dargestellt als Zeichenkette der Form "I1.I2.I3.I4", wobei In eine Zahl zwischen 0 und 255 ist;
  • IPv6: in 128 Bits kodiert und dargestellt als Zeichenkette aus acht durch Doppelpunkte getrennten Gruppen hexadezimaler Ziffern, etwa "2001:db8::8a2e:370:7334". Heute können wir diese Adressen nicht mehr ignorieren: Unsere Programme werden sie akzeptieren.

Eine Maschine kann auch durch einen Namen identifiziert werden. Dieser Name ist nicht zwingend erforderlich, da Anwendungen letztlich immer die IP-Adressen der Maschinen verwenden. Namen sollen den Benutzern das Leben erleichtern: Es ist einfacher, einen Browser nach der URL [https://dev.java] zu fragen als nach der URL, die aus einer der IP-Adressen dieser Website gebildet wird, die sich übrigens je nach Ort der Anfrage ändert.

Eine Maschine kann mehrere IP-Adressen haben: eine Loopback-Adresse, je eine Adresse pro Netzwerk, mit dem sie verbunden ist, sowie IPv4- und IPv6-Adressen.

Eine IP-Adresse kann in Java auf zwei Arten dargestellt werden:

  • als Zeichenkette wie "I1.I2.I3.I4" oder "2001:db8::1";
  • als Objekt vom Typ [InetAddress] (Paket [java.net], in einer kompakten Quelldatei automatisch importiert, da es zum Modul [java.base] gehört).

Die Klasse InetAddress

Die Klasse [InetAddress] hat keinen öffentlichen Konstruktor: Ihre Instanzen werden über statische Erzeugungsmethoden angelegt. Sie hat zwei abgeleitete Klassen, [Inet4Address] und [Inet6Address], eine für jede IP-Version. Zu ihren Methoden gehören die folgenden:

Methode
Rolle
static InetAddress ofLiteral(String string)
(Java 22) wandelt eine in Ziffern geschriebene IPv4- oder IPv6-Adresse in ein [InetAddress]-Objekt um, ohne jemals das DNS abzufragen; wirft eine [IllegalArgumentException] , wenn die Zeichenkette keine IP-Adresse ist. [Inet4Address.ofLiteral] und [Inet6Address.ofLiteral] akzeptieren jeweils nur eine der beiden Versionen
static InetAddress getByName(String nameOrAddress)
liefert die Adresse einer Maschine, die durch ihren Namen oder ihre IP-Adresse identifiziert wird. Ist die Zeichenkette keine IP-Adresse, wird der Name im DNS nachgeschlagen; wirft eine [UnknownHostException] , wenn die Maschine nicht gefunden werden kann
static InetAddress[] getAllByName(String nameOrAddress)
Wie oben, liefert aber alle IP-Adressen der Maschine
static InetAddress getLocalHost()
die Adresse der Maschine, auf der das Programm läuft, zusammen mit ihrem Namen
static InetAddress getLoopbackAddress()
die Loopback-Adresse (127.0.0.1 oder ::1). Ein Dienst, der an diese Adresse gebunden ist, akzeptiert nur Clients, die sich auf derselben Maschine befinden wie er selbst
byte[] getAddress()
liefert die Bytes der Adresse (4 bei IPv4, 16 bei IPv6)
String getHostAddress()
liefert die Adresse in Textform
String getHostName(), String getCanonicalHostName()
der Maschinenname; wurde das Objekt aus einer IP-Adresse erzeugt, wird dieser Name durch eine „umgekehrte“ Abfrage („Reverse Lookup“) im DNS ermittelt (schlägt diese Abfrage fehl, wird die Adresse selbst zurückgegeben)
boolean isLoopbackAddress(), isSiteLocalAddress(), isAnyLocalAddress() …
liefern [true] , wenn die Adresse eine Loopback-Adresse, eine private Adresse (10.x.y.z, 172.16.x.y bis 172.31.x.y, 192.168.x.y), die „Wildcard“-Adresse 0.0.0.0 oder :: ist …

Zwei weitere Klassen ergänzen [InetAddress]:

  • [InetSocketAddress] stellt einen Verbindungspunkt dar: eine IP-Adresse und eine Portnummer. Ihre Methoden [getAddress] und [getPort] liefern diese beiden Angaben. Der Konstruktor [InetSocketAddress(int port)] ordnet den Port der Wildcard-Adresse 0.0.0.0 zu, die alle Adressen der Maschine bezeichnet;
  • [NetworkInterface] stellt eine Netzwerkschnittstelle der Maschine dar (eine Ethernet-Karte, eine WLAN-Karte, die Loopback-Schnittstelle usw.) samt ihren IP-Adressen.

Java besitzt jedoch keine Klasse, die ein Netzwerk in CIDR-Notation darstellt, etwa 193.49.144.0/24: Wir schreiben sie selbst. Das Programm [Internet01.java] veranschaulicht diese Klassen:

// die Klassen InetAddress und InetSocketAddress; ein Netzwerk in CIDR-Notation

void main() {
    // IPv4- und IPv6-Adressen, korrekt oder nicht
    List<String> addresses = List.of("193.49.144.1", "127.0.0.1", "192.168.1", "::1",
            "2001:db8::8a2e:370:7334", "256.1.1.1", "machine");
    for (String string : addresses) {
        try {
            // ofLiteral (Java 22): Parsen einer in Ziffern geschriebenen IP-Adresse, ohne das DNS abzufragen
            InetAddress address = InetAddress.ofLiteral(string);
            String family = address instanceof Inet4Address ? "IPv4" : "IPv6";
            byte[] bytes = address.getAddress();
            String hex = HexFormat.of().withUpperCase().formatHex(bytes);
            IO.println("[%s] -> %s (%s, %d bytes: %s, loopback: %b, private: %b)".formatted(string,
                    address.getHostAddress(), family, bytes.length, hex,
                    address.isLoopbackAddress(), address.isSiteLocalAddress()));
        } catch (IllegalArgumentException e) {
            IO.println("[" + string + "] is not an IP address");
        }
    }

    // getByName akzeptiert eine IP-Adresse oder einen Rechnernamen: dieser wird im DNS nachgeschlagen
    try {
        InetAddress.getByName("256.1.1.1");
    } catch (UnknownHostException e) {
        IO.println("getByName(\"256.1.1.1\") : " + e.getClass().getSimpleName() + " : " + e.getMessage());
    }

    // die Loopback-Adresse und die Wildcard-Adresse (alle Adressen des Rechners)
    IO.println("Loopback=" + InetAddress.getLoopbackAddress());
    IO.println("Wildcard=" + new InetSocketAddress(27100).getAddress());

    // ein Verbindungspunkt = eine IP-Adresse + ein Port
    var point = new InetSocketAddress(InetAddress.getLoopbackAddress(), 27100);
    IO.println("InetSocketAddress: %s (address=%s, port=%d)".formatted(point,
            point.getAddress().getHostAddress(), point.getPort()));
    var point6 = new InetSocketAddress(InetAddress.ofLiteral("::1"), 27100);
    IO.println("InetSocketAddress IPv6: %s (address=%s, port=%d)".formatted(point6,
            point6.getAddress().getHostAddress(), point6.getPort()));

    // ein Netzwerk in CIDR-Notation: Netzwerkadresse / Präfixlänge
    Network network = Network.parse("193.49.144.0/24");
    for (String string : List.of("193.49.144.1", "193.49.145.3")) {
        boolean belongs = network.contains(InetAddress.ofLiteral(string));
        IO.println(string + " belongs to " + network + ": " + belongs);
    }
}

// ein IP-Netzwerk: die Adresse des Netzwerks und die Länge seines Präfixes (Java hat dafür keine Klasse)
record Network(InetAddress address, int prefix) {

    // Parsen einer Zeichenkette der Form Adresse/Präfix
    static Network parse(String cidr) {
        String[] fields = cidr.split("/");
        return new Network(InetAddress.ofLiteral(fields[0]), Integer.parseInt(fields[1]));
    }

    // eine Adresse gehört zum Netzwerk, wenn ihre ersten [prefix] Bits die des Netzwerks sind
    boolean contains(InetAddress machine) {
        byte[] r = address.getAddress();
        byte[] m = machine.getAddress();
        if (r.length != m.length) {
            return false;
        }
        for (int bit = 0; bit < prefix; bit++) {
            // Bit Nr. [bit] der Adresse, vom höchstwertigen Bit des ersten Bytes aus gezählt
            int mask = 0x80 >> (bit % 8);
            if ((r[bit / 8] & mask) != (m[bit / 8] & mask)) {
                return false;
            }
        }
        return true;
    }

    @Override
    public String toString() {
        return address.getHostAddress() + "/" + prefix;
    }
}

Ergebnisse:

> java Internet01.java
[193.49.144.1] -> 193.49.144.1 (IPv4, 4 bytes: C1319001, loopback: false, private: false)
[127.0.0.1] -> 127.0.0.1 (IPv4, 4 bytes: 7F000001, loopback: true, private: false)
[192.168.1] -> 192.168.0.1 (IPv4, 4 bytes: C0A80001, loopback: false, private: true)
[::1] -> 0:0:0:0:0:0:0:1 (IPv6, 16 bytes: 00000000000000000000000000000001, loopback: true, private: false)
[2001:db8::8a2e:370:7334] -> 2001:db8:0:0:0:8a2e:370:7334 (IPv6, 16 bytes: 20010DB80000000000008A2E03707334, loopback: false, private: false)
[256.1.1.1] is not an IP address
[machine] is not an IP address
getByName("256.1.1.1") : UnknownHostException : 256.1.1.1: Name or service not known
Loopback=localhost/127.0.0.1
Wildcard=0.0.0.0/0.0.0.0
InetSocketAddress: localhost/127.0.0.1:27100 (address=127.0.0.1, port=27100)
InetSocketAddress IPv6: /[0:0:0:0:0:0:0:1]:27100 (address=0:0:0:0:0:0:0:1, port=27100)
193.49.144.1 belongs to 193.49.144.0/24: true
193.49.145.3 belongs to 193.49.144.0/24: false

Kommentare:

  • Zeilen 5–6: die zu analysierenden Zeichenketten;
  • Zeile 10: [InetAddress.ofLiteral] (Java 22) wandelt die Zeichenkette in ein [InetAddress]-Objekt um, wenn es sich um eine IPv4- oder IPv6-Adresse handelt, und löst andernfalls eine [IllegalArgumentException] aus (Zeile 17);
  • Zeile 11: Der Operator [instanceof] unterscheidet die beiden IP-Versionen: Das zurückgegebene Objekt ist entweder eine Instanz von [Inet4Address] oder von [Inet6Address];
  • Zeilen 12–13: [getAddress] liefert die Bytes der Adresse, die die Klasse [HexFormat] (Java 17) hexadezimal ausgibt. Wir sehen (Zeile 2 der Ergebnisse), dass 193.49.144.1 aus den vier Bytes C1, 31, 90, 01 besteht und (Zeile 5), dass ::1 aus 15 Nullbytes gefolgt von einem Byte mit dem Wert 1 besteht;
  • Zeile 16: [isLoopbackAddress] und [isSiteLocalAddress] erkennen die Loopback-Adressen und die privaten Adressen nach RFC 1918;
  • Zeile 4 der Ergebnisse: eine Überraschung. Die Zeichenkette "192.168.1" wurde akzeptiert und in 192.168.0.1 umgewandelt. [ofLiteral] akzeptiert tatsächlich die historischen abgekürzten Formen von IPv4-Adressen (bei denen die letzte Zahl alle verbleibenden Bytes belegt). Um zu prüfen, dass eine Eingabe eine vollständige IPv4-Adresse ist, müssen Sie daher zusätzlich kontrollieren, dass sie vier Zahlen enthält;
  • Zeilen 5–6 der Ergebnisse: Die IPv6-Adressen werden von [getHostAddress] in vollständiger Form ausgegeben, ohne die Abkürzung [::] und ohne führende Nullen: [0:0:0:0:0:0:0:1] für [::1]. Das Präfix 2001:db8::/32 ist, wie 192.0.2.0/24 bei IPv4, für Dokumentation reserviert;
  • Zeilen 23–27: Die ältere Methode [getByName] akzeptiert entweder eine IP-Adresse oder einen Hostnamen. Da die Zeichenkette „256.1.1.1“ keine gültige IP-Adresse ist (256 passt nicht in ein einzelnes Byte), interpretiert [getByName] sie als Maschinennamen und fragt das DNS ab, das ihn nicht kennt: Das führt zu einer [UnknownHostException] (Zeile 9 der Ergebnisse). [ofLiteral] wurde in Java 22 hinzugefügt, um diese unerwartete DNS-Abfrage zu verhindern. Die Meldung der Exception stammt hier aus der Systembibliothek von Linux;
  • Zeile 30: die Loopback-Adresse. Wird ein [InetAddress]-Objekt von [toString] ausgegeben, hat es die Form [name/address], wobei der Name leer ist, wenn er unbekannt ist;
  • Zeile 31: die Wildcard-Adresse 0.0.0.0, hier durch eine [InetSocketAddress] ohne Adresse erhalten;
  • Zeilen 34–39: [InetSocketAddress]-Objekte, die eine Adresse und einen Port verbinden. Sie werden (Zeilen 12–13 der Ergebnisse) in der Form [name/address:port] ausgegeben; bei IPv6 steht die Adresse in eckigen Klammern;
  • Zeilen 50–79: ein Record ([record], Kapitel 4), der ein Netzwerk in CIDR-Notation darstellt. In einer kompakten Quelldatei kann er unmittelbar nach der Methode [main] deklariert werden;
  • Zeilen 53–56: Die statische Methode [parse] zerlegt eine Zeichenkette der Form [address/prefix];
  • Zeilen 59–73: Eine Adresse gehört zum Netzwerk, wenn ihre ersten [prefix] Bits mit denen der Netzwerkadresse übereinstimmen. Das Bit Nummer [bit] befindet sich im Byte Nummer [bit / 8]; die Maske [0x80 >> (bit % 8)] isoliert es innerhalb dieses Bytes. Die Zeilen 14–15 der Ergebnisse zeigen, dass 193.49.144.1 zum Netzwerk 193.49.144.0/24 gehört und 193.49.145.3 (die Adresse des Routers in unserem Schaubild, in seinem zweiten Netzwerk) nicht. Genau diesen Test führt eine Maschine durch, um zwischen direktem und indirektem Routing zu wählen.

Das DNS und die Netzwerkschnittstellen

Die Zuordnung zwischen der IP-Kennung und dem Maschinennamen übernimmt das DNS. Es wird über die statischen Methoden [getByName] und [getAllByName] von [InetAddress]abgefragt, die bereits beschrieben wurden; in der Gegenrichtung führen [getHostName] und [getCanonicalHostName] einen Reverse Lookup durch. Diese Methoden sind blockierend: Eine DNS-Anfrage kann einige zehn Millisekunden dauern, bei einem nicht antwortenden Server sogar mehrere Sekunden, in denen der aufrufende Thread blockiert ist. Java bietet keine asynchrone Version dieser Methoden an; seit Java 21 besteht die Lösung schlicht darin, sie in einem virtuellen Thread aufzurufen (Kapitel 8), was beim Warten kaum Overhead verursacht. Seit Java 18 können Sie außerdem den von *[InetAddress] verwendeten Mechanismus zur Namensauflösung überschreiben, indem Sie eine eigene Implementierung der Schnittstelle *[InetAddressResolver] bereitstellen, was für Tests nützlich ist.

Die Klasse [NetworkInterface] liefert mit ihrer statischen Methode [networkInterfaces] einen Stream ([Stream]) der Netzwerkschnittstellen der Maschine; für jede Schnittstelle liefert [getName] ihren Namen, [isUp] zeigt an, ob sie aktiv ist, und [inetAddresses] liefert einen Stream ihrer Adressen (IP).

Das Programm [Internet02.java] zeigt den Namen und die Netzwerkschnittstellen der Maschine an, auf der es läuft, und liefert dann interaktiv die Zuordnungen zwischen Maschinenname und IP-Adressen:

// zeigt den Namen und die Netzwerkschnittstellen des lokalen Rechners an
// gibt dann interaktiv Auskunft über die Rechner des Netzwerks
// die durch einen Namen oder eine IP-Adresse identifiziert werden

void main() throws IOException {
    // lokaler Rechner
    InetAddress local = InetAddress.getLocalHost();
    IO.println("Local machine = " + local.getHostName() + " (" + local.getHostAddress() + ")");
    // seine aktiven Netzwerkschnittstellen mit ihren Adressen
    for (NetworkInterface card : NetworkInterface.networkInterfaces().filter(this::active).toList()) {
        String ips = card.inetAddresses().map(InetAddress::getHostAddress).collect(Collectors.joining(", "));
        IO.println("Interface " + card.getName() + " : " + ips);
    }

    // interaktive Fragen und Antworten
    while (true) {
        // Eingabe des Namens oder der IP-Adresse des gesuchten Rechners
        String input = IO.readln("Machine looked for (nothing to stop): ");
        String machine = input == null ? "" : input.strip().toLowerCase();
        // fertig?
        if (machine.isEmpty()) {
            break;
        }
        try {
            // Abfrage des DNS: alle IP-Adressen des Rechners
            InetAddress[] addresses = InetAddress.getAllByName(machine);
            // der Name des Rechners: Reverse-Lookup, wenn eine IP-Adresse angegeben wurde
            IO.println("Machine: " + addresses[0].getHostName());
            // seine IP-Adressen
            String ips = Arrays.stream(addresses).map(InetAddress::getHostAddress)
                    .collect(Collectors.joining(", "));
            IO.println("IP addresses: " + ips);
        } catch (UnknownHostException e) {
            // der Rechner wurde nicht gefunden
            IO.println("Unable to find the machine [" + machine + "] : " + e.getMessage());
        }
    }
}

// ist eine Netzwerkschnittstelle aktiv? (isUp kann eine SocketException werfen)
boolean active(NetworkInterface card) {
    try {
        return card.isUp();
    } catch (SocketException e) {
        return false;
    }
}

Ergebnisse:

> java Internet02.java
Local machine = vm (127.0.0.1)
Interface eth0 : 192.0.2.2
Interface lo : 127.0.0.1
Machine looked for (nothing to stop): localhost
Machine: localhost
IP addresses: 127.0.0.1
Machine looked for (nothing to stop): vm
Machine: vm
IP addresses: 127.0.0.1
Machine looked for (nothing to stop): 127.0.0.1
Machine: localhost
IP addresses: 127.0.0.1
Machine looked for (nothing to stop): ::1
Machine: 0:0:0:0:0:0:0:1
IP addresses: 0:0:0:0:0:0:0:1
Machine looked for (nothing to stop): xx
Unable to find the machine [xx] : xx: Name or service not known
Machine looked for (nothing to stop): 

Kommentare:

  • Zeilen 7–8: der Name und die Adresse der lokalen Maschine. Unsere Testmaschine ist eine virtuelle Linux-Maschine mit dem Namen [vm]; bei Ihnen ist es natürlich der Name Ihres eigenen Rechners;
  • Zeilen 10–13: die aktiven Netzwerkschnittstellen und ihre Adressen. Der Filter [filter(this::active)] verwendet eine Referenz auf die Methode [active] des aktuellen Objekts (Kapitel 7); Sie können [isUp] nicht direkt in einer Methodenreferenz schreiben, da es eine geprüfte Exception ([SocketException]) auslöst, die das funktionale Interface [Predicate] nicht zulässt: Die Methode [active] (Zeilen 41–47) fängt sie ab;
  • Zeile 18: [IO.readln] (Java 25) zeigt die Eingabeaufforderung an und liest eine Zeile von der Tastatur; es liefert [null] , wenn die Standardeingabe geschlossen ist;
  • Zeile 26: die DNS-Abfrage. Ist der Name (oder die Adresse) unbekannt, wird eine [UnknownHostException] ausgelöst (Zeile 33);
  • Zeile 28: der Maschinenname. Wurde eine IP-Adresse angegeben, führt [getHostName] einen Reverse Lookup durch;
  • Zeilen 30–31: Die Adressen der Maschine werden mit der Stream-API zu einer einzigen Zeichenkette zusammengefasst.

Die Ergebnisse verdienen einige Anmerkungen. Sie hängen von der Konfiguration der Maschine ab: Erwarten Sie nicht, auf Ihrem eigenen System exakt dieselben Ergebnisse zu erhalten.

  • Zeilen 2–4: Die Testmaschine hat zwei aktive Schnittstellen: [eth0], die mit dem Netzwerk verbunden ist, und [lo], die Loopback-Schnittstelle. Der Maschinenname wird durch die Datei [/etc/hosts] der Adresse 127.0.0.1 zugeordnet;
  • Zeilen 5–7: Der Name [localhost] entspricht der Loopback-Adresse 127.0.0.1. Auf einer Maschine mit aktivem IPv6 würde auch ::1 zurückgegeben;
  • Zeile 12: Mit der IP-Adresse hat [getHostName] einen Reverse Lookup durchgeführt und den der Adresse zugeordneten Namen zurückgegeben;
  • Zeile 15: Der Reverse Lookup für ::1 ist fehlgeschlagen, weil die Datei [/etc/hosts] auf unserer Testmaschine dieser Adresse keinen Namen zuordnet; [getHostName] hat die Adresse selbst zurückgegeben. Unter Windows würde der Maschinenname zurückgegeben;
  • Zeile 18: Der Name [xx] ist unbekannt. Die Meldung der Exception stammt aus der Systembibliothek von Linux; unter Windows würde sie anders lauten.

Auf einer mit dem Internet verbundenen Maschine können Sie auch einen öffentlichen Namen wie [dev.java] abfragen. Das liefert Adressen, die je nach Ort und Zeitpunkt der Anfrage variieren. Wir geben dieses Ergebnis nicht wieder, da unsere Testmaschine keinen Internetzugang hat.

12.3. Grundlagen der Web-Programmierung

12.3.1. Allgemeines

Betrachten wir die Kommunikation zwischen zwei entfernten Maschinen A und B:

Image

Wenn eine Anwendung AppA auf Maschine A mit einer Anwendung AppB auf Maschine B im Internet kommunizieren möchte, muss sie mehrere Dinge wissen:

  • die IP-Adresse oder den Namen von Maschine B;
  • die Portnummer, die die Anwendung AppB verwendet. Maschine B kann nämlich viele Anwendungen beherbergen, die über das Internet arbeiten. Wenn sie Informationen aus dem Netzwerk empfängt, muss sie wissen, für welche Anwendung die Informationen bestimmt sind. Die Anwendungen auf Maschine B greifen über Schnittstellen, die Kommunikationsports heißen, auf das Netzwerk zu. Die Nummer des Zielports steht in dem von Maschine B empfangenen Segment, damit dieses an die richtige Anwendung ausgeliefert werden kann;
  • die Kommunikationsprotokolle, die Maschine B versteht. In unserer Untersuchung verwenden wir ausschließlich die Protokolle TCP/IP;
  • das Kommunikationsprotokoll, das die Anwendung AppB unterstützt. Die Maschinen A und B „unterhalten“ sich nämlich miteinander. Was sie austauschen, wird in die TCP/IP-Protokolle gekapselt. Wenn die Anwendung AppB am Ende der Kette jedoch die von der Anwendung AppA gesendeten Informationen empfängt, muss sie sie interpretieren können. Das ist vergleichbar mit einer Situation, in der zwei Personen, A und B, telefonieren: Ihr Gespräch wird über das Telefon übertragen, aber wenn A Französisch spricht und B diese Sprache nicht versteht, können A und B kein sinnvolles Gespräch führen. Die beiden kommunizierenden Anwendungen müssen sich daher auf die Art der Kommunikation einigen, die sie verwenden. Die Kommunikation mit einem Webserver unterscheidet sich zum Beispiel von der Kommunikation mit einem Mailserver: Diese beiden Dienste akzeptieren nicht dieselben Befehle. Sie haben unterschiedliche Kommunikationsprotokolle.

12.3.2. Merkmale des Protokolls TCP

Hier konzentrieren wir uns ausschließlich auf die Netzwerkkommunikation über das Transportprotokoll TCP. Rufen wir uns seine wichtigsten Merkmale für Programmierer in Erinnerung:

  • Zunächst wird eine Verbindung zwischen einem Port auf der Client-Maschine und einem Port auf der Server-Maschine aufgebaut. Sie wird durch vier Angaben identifiziert: die IP-Adresse und den Port des Clients sowie die IP-Adresse und den Port des Servers;
  • die Verbindung führt zwei Bytefolgen (Streams), eine pro Richtung (Vollduplex). Die Bytes kommen in der Reihenfolge an, in der sie übertragen wurden, ohne Verlust und ohne Duplikate;
  • TCP kennt das Konzept einer Nachricht nicht: Es ist Sache des Kommunikationsprotokolls der Anwendung, Anfragen und Antworten abzugrenzen (durch einen Zeilenumbruch, eine festgelegte Länge, das Schließen der Verbindung usw.);
  • einer der beiden Partner schließt die Verbindung; der andere erkennt dies, wenn er das Ende des Lese-Streams erreicht.

12.3.3. Die Client-Server-Beziehung

Die Kommunikation im Internet ist oft asymmetrisch: Maschine A baut eine Verbindung zu Maschine B auf, um einen Dienst anzufordern. Sie gibt an, dass sie eine Verbindung zum Dienst SB1 von Maschine B herstellen möchte. Maschine B nimmt die Anfrage an oder lehnt sie ab. Nimmt sie an, kann Maschine A ihre Anfragen an den Dienst SB1 senden. Diese Anfragen müssen dem Kommunikationsprotokoll entsprechen, das der Dienst SB1 versteht. So entsteht ein Frage-Antwort-Dialog zwischen Maschine A, der Client-Maschine, und Maschine B, der Server-Maschine. Einer der beiden Partner schließt die Verbindung.

12.3.4. Architektur des Clients

Die Architektur eines Netzwerkprogramms, das die Dienste einer Server-Anwendung anfordert, sieht wie folgt aus:

open the connection with the service SB1 of machine B
if successful then
    while it is not finished
        prepare a request
        send it to machine B
        wait for and retrieve the response
        process it
    end while
end if
close the connection

12.3.5. Architektur des Servers

Die Architektur eines Programms, das Dienste anbietet, sieht wie folgt aus:

1
2
3
4
5
6
open the service on the local machine
while the service is open
    listen for connection requests on a so-called listening port
    when there is a request, accept it and have the resulting connection
        (service connection) handled by another thread
end while

Das Server-Programm behandelt die erste Verbindungsanfrage eines Clients anders als seine nachfolgenden Dienstanfragen. Das lauschende Programm erbringt den Dienst nicht selbst: Täte es das, würde es während der Dienstleistung nicht mehr auf Verbindungsanfragen lauschen, und andere Clients würden nicht bedient. Es geht daher anders vor: Sobald auf dem Listening-Port eine Verbindungsanfrage eingeht und angenommen wird, delegiert der Server die Aufgabe, den vom Client angeforderten Dienst zu erbringen, über die soeben aufgebaute Dienstverbindung an einen anderen Thread. So können mehrere Clients gleichzeitig bedient werden:

Image

Manchmal heißt es, auf der Serverseite verwende die Dienstverbindung einen anderen, zufällig gewählten Port. Das ist falsch: Alle Dienstverbindungen verwenden den Listening-Port des Servers; sie unterscheiden sich voneinander durch die Adresse und den Port des Clients, die verschieden sind. Wir werden das in der Ausgabe unseres Echo-Servers sehen.

Ein Dienst-Thread hat folgende Struktur:

1
2
3
4
5
6
while the service has not been fully provided
    wait for a request on the service connection
    when there is one, build the response
    send the response over the service connection
end while
close the service connection

12.4. Erkundung der Kommunikationsprotokolle des Internets

12.4.1. Einführung

Wenn sich ein Client mit einem Server verbindet, entsteht zwischen beiden ein Dialog. Die Art dieses Dialogs bildet das, was man das Kommunikationsprotokoll des Servers nennt. Zu den gebräuchlichsten Internetprotokollen gehören die folgenden:

  • HTTP: HyperText Transfer Protocol, das Protokoll für die Kommunikation mit einem Webserver (HTTP-Server);
  • SMTP: Simple Mail Transfer Protocol, das Protokoll für die Kommunikation mit einem Server zum Versenden von E-Mails (SMTP-Server);
  • POP: Post Office Protocol, das Protokoll für die Kommunikation mit einem Server zur Speicherung von E-Mails (POP-Server). Es dient dazu, empfangene E-Mails abzurufen, nicht, sie zu senden. IMAP erfüllt denselben Zweck;
  • FTP: File Transfer Protocol, das Protokoll für die Kommunikation mit einem Server zur Dateispeicherung (FTP-Server).

Diese Protokolle zeichnen sich in ihren historischen Versionen dadurch aus, dass sie textbasiert sind: Client und Server tauschen Textzeilen aus, die durch die zwei Zeichen \r\n (Wagenrücklauf, Zeilenvorschub) abgeschlossen werden. Wenn Sie einen Client haben, der in der Lage ist,

  • eine Verbindung zu einem TCP-Server aufzubauen;
  • die vom Server gesendeten Textzeilen auf der Konsole anzuzeigen;
  • die Textzeilen, die ein Benutzer auf der Tastatur eingibt, an den Server zu senden,

dann können Sie mit einem TCP-Server kommunizieren, der ein textbasiertes Protokoll verwendet, sofern Sie die Regeln dieses Protokolls kennen.

Das Programm [telnet], das früher auf Unix- und Windows-Maschinen verfügbar war, ist ein solcher Client; das Werkzeug PuTTY, konfiguriert im Raw-Verbindungsmodus, ist ein anderer. Der Client [telnet] ist unter Windows nicht mehr standardmäßig installiert, und die meisten öffentlichen Server akzeptieren keine unverschlüsselte Kommunikation mehr. Wir gehen deshalb anders vor:

  • für HTTP verwenden wir das Werkzeug [curl], das unter Windows 10 und 11, macOS und Linux standardmäßig verfügbar ist und die Details der Austausche anzeigt, gefolgt vom generischen TCP-Client, den wir später in diesem Kapitel schreiben. Unter Windows sind in PowerShell [curl] ein Alias für den Befehl [Invoke-WebRequest]: Sie müssen [curl.exe] eingeben;
  • da wir keinen Zugriff auf echte Server haben, fragen wir einen kleinen Webserver ab, den wir selbst schreiben und der auf der lokalen Maschine läuft;
  • für SMTP, POP und FTP stellen wir Beispieldialoge vor, die den RFC entsprechen, die diese Protokolle definieren.

12.4.2. Ein Test-Webserver

Unser Test-Webserver verwendet den kleinen HTTP-Server, der im JDK im Modul [jdk.httpserver] (Paket [com.sun.net.httpserver]) enthalten ist. Trotz seines Paketnamens ist es eine öffentliche und gut dokumentierte API, die seit Java 6 verfügbar ist; sie genügt, um einen Testserver in einer einzigen Datei ohne Bibliotheken zu schreiben. Echte Webservices verwenden üblicherweise einen ausgewachsenen Server wie Tomcat, den wir im nächsten Kapitel mit Spring Boot kennenlernen. Sie müssen dieses Programm noch nicht im Detail verstehen – es genügt zu wissen, was es zurückgibt. Das Programm [Internet03.java] lautet wie folgt:

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;

import static java.nio.charset.StandardCharsets.UTF_8;

// ein kleiner lokaler Webserver, der das Ziel unserer HTTP-Clients sein wird
// er verwendet den im JDK bereitgestellten HTTP-Server (Modul jdk.httpserver)
// Aufruf: java Internet03.java [port]   (standardmäßig Port 27110); Stopp mit Ctrl-C

// die Startseite: ein HTML-Dokument
final String HOME = """
        <!DOCTYPE html>
        <html lang="en">
        <head><meta charset="utf-8"><title>Test server</title></head>
        <body><h1>Welcome to the test server of the Java course</h1></body>
        </html>
        """;

int port;

void main(String[] args) throws IOException {
    port = args.length == 1 ? Integer.parseInt(args[0]) : 27110;
    // der Server lauscht auf der Loopback-Adresse: er ist nur vom Rechner selbst aus erreichbar
    HttpServer server = HttpServer.create(new InetSocketAddress(InetAddress.getLoopbackAddress(), port), 0);
    // alle URLs werden von der Methode [process] bearbeitet
    server.createContext("/", this::process);
    server.start();
    IO.println("Web server started on http://localhost:" + port);
}

// Bearbeitung einer Anfrage: Wahl der Antwort anhand der URL, dann Konsolenprotokoll
void process(HttpExchange exchange) throws IOException {
    try (exchange) {
        String method = exchange.getRequestMethod();
        String path = exchange.getRequestURI().getPath();
        if (!method.equals("GET") && !method.equals("HEAD")) {
            // die URLs akzeptieren nur die Methoden GET und HEAD
            exchange.sendResponseHeaders(405, -1);
        } else {
            switch (path) {
                // die Startseite, mit ihrer Größe
                case "/" -> send(exchange, HOME, "text/html; charset=utf-8", true);
                // ein aus einem Parameter der URL erstellte Textdokument, in Chunks gesendet
                case "/hello" -> send(exchange, "Hello " + parameter(exchange, "name", "unknown") + "!",
                        "text/plain; charset=utf-8", false);
                // vorübergehende Weiterleitung (302) auf eine relative Adresse
                case "/old" -> redirect(exchange, 302, "/hello?name=visitor");
                // dauerhafte Weiterleitung (301) auf eine absolute Adresse
                case "/moved" -> redirect(exchange, 301, "http://localhost:" + port + "/");
                // eine Weiterleitung, die sich im Kreis dreht
                case "/loop" -> redirect(exchange, 302, "/loop");
                // jede andere URL: 404 Not Found, ohne Dokument (-1)
                default -> exchange.sendResponseHeaders(404, -1);
            }
        }
        // Konsolenprotokoll: die Anfrage und der Statuscode ihrer Antwort
        IO.println("%s %s %s -> %d".formatted(method, exchange.getRequestURI(), exchange.getProtocol(),
                exchange.getResponseCode()));
    }
}

// Senden eines Textdokuments: mit seiner Größe (Content-length) oder in Chunks (chunked)
void send(HttpExchange exchange, String text, String type, boolean withSize) throws IOException {
    byte[] bytes = text.getBytes(UTF_8);
    exchange.getResponseHeaders().set("Content-Type", type);
    if (exchange.getRequestMethod().equals("HEAD")) {
        // HEAD: nur die Header; die Größe, die das Dokument hätte, wird angegeben
        exchange.getResponseHeaders().set("Content-Length", String.valueOf(bytes.length));
        exchange.sendResponseHeaders(200, -1);
        return;
    }
    // Größe 0: in Chunks gesendetes Dokument, dessen Größe vorher unbekannt ist
    exchange.sendResponseHeaders(200, withSize ? bytes.length : 0);
    exchange.getResponseBody().write(bytes);
}

// eine Weiterleitung: Code 301 oder 302 und Header Location, ohne Dokument
void redirect(HttpExchange exchange, int code, String address) throws IOException {
    exchange.getResponseHeaders().set("Location", address);
    exchange.sendResponseHeaders(code, -1);
}

// der Wert eines Parameters der URL (?name=value&...), dekodiert
String parameter(HttpExchange exchange, String name, String defaultValue) {
    String query = exchange.getRequestURI().getRawQuery();
    if (query == null) {
        return defaultValue;
    }
    for (String pair : query.split("&")) {
        String[] fields = pair.split("=", 2);
        if (fields[0].equals(name) && fields.length == 2) {
            return URLDecoder.decode(fields[1], UTF_8);
        }
    }
    return defaultValue;
}

Kommentare:

  • Zeilen 1–2: Das Modul [jdk.httpserver] gehört nicht zum Modul [java.base], das in eine kompakte Quelldatei automatisch importiert wird; seine Klassen müssen importiert werden. Zeile 4 ist ein statischer Import: Er erlaubt es, [UTF_8] statt [StandardCharsets.UTF_8] zu schreiben;
  • Zeilen 11–17: die Startseite, ein kleines HTML-Dokument, geschrieben als [""" ... """]-Textblock (Java 15), der das Maskieren von Anführungszeichen überflüssig macht;
  • Zeile 22: der Listening-Port, standardmäßig 27110;
  • Zeile 24: Der Server lauscht auf der Loopback-Adresse 127.0.0.1: Er ist nur von der Maschine selbst aus erreichbar. Der zweite Parameter von [create] ist die Größe der Verbindungswarteschlange (0: Systemstandard);
  • Zeile 26: Alle URL, die mit [/] beginnen – und damit alle URL –, werden der Methode [process] zugewiesen. Der zweite Parameter von [createContext] ist ein [HttpHandler], ein funktionales Interface, dessen einzige Methode [handle(HttpExchange)] den aktuellen Austausch erhält: die Anfrage des Clients und die zu erstellende Antwort;
  • Zeile 27: Der Server beginnt, in eigenen Threads zu laufen; die Methode [main] endet, aber das Programm läuft weiter, bis es mit Strg+C beendet wird;
  • Zeile 33: Ein [HttpExchange] muss geschlossen werden, sobald die Antwort gesendet ist: Das übernimmt das [try] mit Ressourcen;
  • Zeilen 36–38: Nur die Methoden [GET] und [HEAD] werden akzeptiert; die anderen erhalten eine Antwort 405 (Methode nicht erlaubt);
  • Zeile 42: Die URL [/] liefert die Startseite;
  • Zeile 44: Die URL [/hello?name=xx] liefern den Text [Hello xx!];
  • Zeile 47: Die URL [/old] bewirkt eine temporäre Weiterleitung (Statuscode 302) auf die relative Adresse [/hello?name=visitor];
  • Zeile 49: Die URL [/moved] bewirkt eine permanente Weiterleitung (Statuscode 301) auf die absolute Adresse [http://localhost:27110/];
  • Zeile 51: Die URL [/loop] leitet auf sich selbst weiter: Ein Client, der den Weiterleitungen blind folgte, würde nie anhalten;
  • Zeile 53: Jede andere URL-Anfrage erhält eine Antwort 404 (Seite nicht gefunden). Die Methode [sendResponseHeaders(code, size)] sendet die Statuszeile und die Header; eine Größe von -1 bedeutet, dass kein Dokument folgt;
  • Zeilen 57–58: Jede verarbeitete Anfrage wird zusammen mit dem Statuscode der Antwort auf der Konsole angezeigt;
  • Zeilen 63–75: Senden eines Textdokuments. Die Antwort-Header werden mit [getResponseHeaders().set] (Zeile 65) gesetzt, anschließend übermittelt [sendResponseHeaders] sie zusammen mit der Größe des Dokuments; danach wird das Dokument über [getResponseBody()] in den Stream geschrieben (Zeile 74). Eine Größe von 0 (Zeile 73) bedeutet „unbekannte Größe“: Das Dokument wird dann in Teilstücken (Chunks) gesendet, wie wir später sehen werden. Bei einer [HEAD]-Anfrage wird kein Dokument gesendet, aber die Größe, die es gehabt hätte, wird angegeben (Zeilen 66–71);
  • Zeilen 78–81: eine Weiterleitung, bestehend aus einem Statuscode und einem [Location]-Header, der die neue Adresse angibt;
  • Zeilen 84–96: der Wert eines Parameters in der URL. [getRawQuery] liefert den Teil der URL, der auf [?] folgt, noch codiert; [URLDecoder.decode] decodiert jeden Wert (warum die Werte codiert sind, sehen wir später).

Der Server wird in einem ersten Eingabeaufforderungsfenster gestartet. Er zeigt Folgendes an:

1
2
3
4
> java Internet03.java
Web server started on http://localhost:27110
GET / HTTP/1.1 -> 200
GET /unknown HTTP/1.1 -> 404

Die Zeilen 3–4 sind bei den Tests im folgenden Absatz erschienen. Der Server kann mit Strg-C beendet werden.

12.4.3. Das HTTP-Protokoll (HyperText Transfer Protocol)

Während der Server läuft, fordern wir in einem zweiten Eingabeaufforderungsfenster mit dem Werkzeug [curl] die Wurzel [/] der Site [http://localhost:27110] an. Seine Option [-v] (verbose) zeigt den gesamten HTTP-Dialog an; die Option [-s] (silent) unterdrückt die Anzeige des Übertragungsfortschritts:

> curl -sv http://localhost:27110/
* Host localhost:27110 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
*   Trying 127.0.0.1:27110...
* Connected to localhost (127.0.0.1) port 27110
> GET / HTTP/1.1
> Host: localhost:27110
> User-Agent: curl/8.5.0
> Accept: */*
> 
< HTTP/1.1 200 OK
< Date: Sat, 03 Oct 2026 17:40:04 GMT
< Content-type: text/html; charset=utf-8
< Content-length: 171
< 
{ [171 bytes data]
* Connection #0 to host localhost left intact
<!DOCTYPE html>
<html lang="en">
<head><meta charset="utf-8"><title>Test server</title></head>
<body><h1>Welcome to the test server of the Java course</h1></body>
</html>

Erläuterungen:

  • Zeilen, die mit [*] beginnen, enthalten Informationen von [curl]; Zeilen, die mit [>] beginnen, wurden an den Server gesendet; Zeilen, die mit [<] beginnen, wurden vom Server empfangen; die Zeile [{ [171 bytes data]] zeigt den Eingang der 171 Bytes des Dokuments an, das am Ende angezeigt wird;
  • Zeilen 2–6: [curl] hat die Adressen von [localhost] ermittelt (::1 in IPv6 und 127.0.0.1 in IPv4) und sich mit Port 27110 auf der Adresse 127.0.0.1 verbunden;
  • Zeilen 7–11: die Anfrage des Clients. Sie besteht aus einer ersten Zeile in der Syntax [method URL version] (hier wird die Methode [GET] verwendet, um das Dokument [/], also die Wurzel der Site, in HTTP/1.1 anzufordern), gefolgt von HTTP-Headern der Form [Name: value], und endet mit einer Leerzeile;
  • Zeile 8: Der Header [Host] gibt den angefragten Rechner und Port an; er ist in HTTP/1.1 erforderlich, weil ein einzelner Server mehrere Sites hosten kann;
  • Zeile 9: die Kennung der Client-Software;
  • Zeile 10: die vom Client akzeptierten Dokumenttypen – hier alle;
  • Zeilen 12–16: die Antwort des Servers: eine Statuszeile und Header, ebenfalls gefolgt von einer Leerzeile;
  • Zeile 12: die Statuszeile mit der Syntax [version code message]. Der Code 200 zeigt an, dass das angeforderte Dokument gefunden wurde;
  • Zeile 13: Datum und Uhrzeit des Servers, stets in koordinierter Weltzeit (GMT);
  • Zeile 14: der Dokumenttyp (ein HTML-Dokument) und seine Codierung (UTF-8);
  • Zeile 15: die Größe des Dokuments in Bytes. So erkennt der Client, wo das Dokument endet. Beachten Sie, dass der JDK-Server die Header-Namen mit nur einem Großbuchstaben schreibt ([Content-type], [Content-length]): Das ist unerheblich, da bei HTTP-Header-Namen die Groß- und Kleinschreibung keine Rolle spielt. Außerdem sendet er nicht den optionalen Header [Server], mit dem sich die meisten Server identifizieren ([Server: Apache], [Server: nginx] …);
  • Zeile 18: In HTTP/1.1 bleibt die Verbindung nach der Antwort standardmäßig geöffnet (Modus „Keep-Alive“), damit weitere Anfragen bedient werden können; [curl] lässt sie offen und schließt sie dann beim Beenden;
  • Zeilen 19–23: das vom Server gesendete Dokument.

Fordern wir nun ein Dokument an, das nicht existiert:

> curl -sv http://localhost:27110/unknown
* Host localhost:27110 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
*   Trying 127.0.0.1:27110...
* Connected to localhost (127.0.0.1) port 27110
> GET /unknown HTTP/1.1
> Host: localhost:27110
> User-Agent: curl/8.5.0
> Accept: */*
> 
< HTTP/1.1 404 Not Found
< Date: Sat, 03 Oct 2026 17:40:04 GMT
< Content-length: 0
< 
* Connection #0 to host localhost left intact
  • Zeile 7: Wir haben ein nicht vorhandenes Dokument angefordert;
  • Zeile 12: Der Server hat mit dem Statuscode 404 geantwortet, was bedeutet, dass das angeforderte Dokument nicht gefunden wurde;
  • Zeile 14: Das gesendete Dokument ist leer. Unser Server hängt, wie viele andere, an eine 404-Antwort kein Dokument an; andere Server senden eine kurze Erläuterungsseite. Ein Browser, der eine 404-Antwort ohne Dokument erhält, zeigt seine eigene Fehlerseite an.

Die Statuscodes sind in fünf Kategorien eingeteilt: 1xx (Information), 2xx (Erfolg, 200 OK), 3xx (Weiterleitung, 301 und 302, die wir später behandeln), 4xx (Client-Fehler: 404 Not Found, 401 Unauthorized, 403 Forbidden …), 5xx (Server-Fehler: 500 Internal Server Error …).

Der Browser macht dasselbe wie [curl]: Er sendet eine HTTP-Anfrage, empfängt die Header und das Dokument und zeigt das Dokument anschließend an. Mit den Entwicklertools des Browsers (Taste F12, Registerkarte „Netzwerk“) können Sie die ausgetauschten Header einsehen.

Einige Anmerkungen zum aktuellen Stand von HTTP:

  • HTTPS ist heute der Standard: Browser kennzeichnen eine Site, die reines HTTP verwendet, als „nicht sicher“. Bei HTTPS geht dem HTTP-Dialog eine TLS-Aushandlung voraus, und alles, was danach folgt, ist verschlüsselt. Es ist daher nicht mehr möglich, mit einem einfachen TCP-Client „von Hand“ mit einem HTTPS-Server zu kommunizieren. Sie können den Dialog jedoch weiterhin mit [curl] beobachten, das den TLS-Handshake durchführt und die Header anschließend im Klartext anzeigt. Nur zur Veranschaulichung (wir geben das Ergebnis nicht wieder, da unsere Testmaschine keinen Internetzugang hat) würde der Befehl [curl -v https://dev.java/] lauten;
  • HTTP/1.1 (heute RFC 9112) ist ein textbasiertes Protokoll, nämlich das, das wir hier untersuchen. HTTP/2 (2015, heute RFC 9113) behält dieselben Methoden, Header und Statuscodes bei, überträgt sie aber in einem komprimierten Binärformat und sendet mehrere Anfragen gleichzeitig über eine einzige TCP-Verbindung. HTTP/3 (2022, RFC 9114) tut dasselbe über QUIC und damit über UDP. Browser und Server wählen automatisch die neueste Version, die sie gemeinsam beherrschen; [curl] verwendet ohne besondere Optionen für eine URL [http://] HTTP/1.1.

12.4.4. Das SMTP-Protokoll (Simple Mail Transfer Protocol)

SMTP-Server tauschen E-Mails untereinander über Port 25 aus. Ein E-Mail-Client, der eine Nachricht versendet, übergibt sie nach der Authentifizierung dem SMTP-Server seines Providers auf Port 587 (Submission, mit Wechsel in den verschlüsselten Modus über den Befehl [STARTTLS]) oder 465 (von Anfang an verschlüsselte Verbindung). Internetanbieter blockieren in der Regel ausgehende Verbindungen zu Port 25 von den Routern ihrer Kunden, um den Spam infizierter Rechner einzudämmen: Eine unverschlüsselte Kommunikation mit einem SMTP-Server ist daher von einem privaten Rechner aus heute praktisch unmöglich.

Hier ist ein Beispiel für einen SMTP-Dialog gemäß RFC 5321. Es handelt sich nicht um eine Ausführung: Zeilen mit dem Präfix [C:] werden vom Client gesendet, Zeilen mit dem Präfix [S:] vom Server, und die Domains [example.org] und [example.com] sind für Beispiele reserviert:

S: 220 mail.example.com ESMTP ready
C: EHLO poste.example.org
S: 250-mail.example.com
S: 250-SIZE 10240000
S: 250-STARTTLS
S: 250 8BITMIME
C: MAIL FROM:<alice@example.org>
S: 250 2.1.0 Ok
C: RCPT TO:<bob@example.com>
S: 250 2.1.5 Ok
C: DATA
S: 354 End data with <CR><LF>.<CR><LF>
C: From: alice@example.org
C: To: bob@example.com
C: Subject: test
C:
C: line1
C: line2
C: .
S: 250 2.0.0 Ok: queued as 4F2A81C0
C: QUIT
S: 221 2.0.0 Bye
  • Zeile 1: Willkommensnachricht des Servers. Jede Serverantwort beginnt mit einem dreistelligen Code: 2xx steht für Erfolg, 3xx bedeutet „bitte fortfahren“, und 4xx und 5xx zeigen einen Fehler an;
  • Zeile 2: Der Client stellt sich vor. Der Befehl [EHLO] hat den alten Befehl [HELO] abgelöst: Er fragt den Server nach einer Liste der von ihm unterstützten Erweiterungen;
  • Zeilen 3–6: Die mehrzeilige Antwort des Servers. Der Bindestrich nach dem Code zeigt an, dass die Antwort fortgesetzt wird; die letzte Zeile hat stattdessen ein Leerzeichen. Hier gibt der Server an, dass er Nachrichten bis zu 10 MB Größe akzeptiert, den verschlüsselten Modus unterstützt und 8-Bit-Zeichen akzeptiert;
  • Zeile 7: die Adresse des Absenders;
  • Zeile 9: die Adresse des Empfängers (der Befehl kann für mehrere Empfänger wiederholt werden);
  • Zeile 11: Der Client kündigt die Nachricht an;
  • Zeile 12: Der Server fordert den Client auf, die Nachricht zu senden, und erinnert ihn daran, wie sie zu beenden ist;
  • Zeilen 13–19: die Nachricht, bestehend aus Headern ([From], [To], [Subject] …), einer Leerzeile und dem Textkörper, und endend mit einer Zeile, die nur einen Punkt enthält;
  • Zeile 20: Der Server hat die Nachricht akzeptiert und in seine Warteschlange gestellt;
  • Zeilen 21–22: Der Client signalisiert, dass er fertig ist; der Server schließt die Verbindung.

12.4.5. Das POP-Protokoll (Post Office Protocol)

POP3-Server arbeiten auf Port 110 oder, für eine per TLS verschlüsselte Verbindung, auf Port 995 – derzeit die einzige Möglichkeit, die die meisten Provider anbieten, da das Passwort über die Verbindung übertragen wird. Hier ist ein typischer POP3-Dialog gemäß dem RFC von 1939, dargestellt nach denselben Konventionen wie der vorherige:

S: +OK POP3 server ready
C: USER bob
S: +OK
C: PASS ********
S: +OK Logged in.
C: LIST
S: +OK 2 messages:
S: 1 1205
S: 2 1916
S: .
C: RETR 2
S: +OK 1916 octets
S: Return-Path: <alice@example.org>
S: Delivered-To: bob@example.com
S: ...
S: Date: Sat, 03 Oct 2026 10:59:25 +0200
S: From: alice@example.org
S: To: bob@example.com
S: Subject: test
S:
S: line1
S: line2
S: .
C: QUIT
S: +OK Logging out.
  • Zeile 1: Willkommensnachricht des Servers. Die Antworten beginnen mit [+OK] (Erfolg) oder [-ERR] (Fehler);
  • Zeile 2: Der Client übermittelt seinen Benutzernamen, also den Namen, unter dem er seine E-Mails liest;
  • Zeile 4: das Passwort des Clients (hier verborgen);
  • Zeile 6: Der Client fordert eine Liste seiner E-Mails an;
  • Zeilen 7–10: die Liste der Nachrichten im Postfach des Clients im Format [message number, size in bytes], abgeschlossen durch eine Zeile, die nur einen Punkt enthält;
  • Zeile 11: Nachricht Nr. 2 wird angefordert;
  • Zeilen 12–23: Nachricht Nr. 2 mit ihren Headern, einer Leerzeile und ihrem Textkörper, ebenfalls mit einem Punkt abgeschlossen;
  • Zeilen 24–25: Der Client zeigt an, dass er fertig ist; der Server schließt die Verbindung.

POP3 ist darauf ausgelegt, E-Mails auf den Rechner des Benutzers herunterzuladen. Es steht heute in starker Konkurrenz zu IMAP (Port 143 bzw. 993 mit TLS; RFC 9051), das die Nachrichten auf dem Server belässt und es ermöglicht, sie von mehreren Geräten aus sowie über webbasierte E-Mail-Clients einzusehen und zu organisieren.

12.4.6. Das FTP-Protokoll (File Transfer Protocol)

Das FTP-Protokoll (RFC 959) ist komplexer als die zuvor beschriebenen: Der Dialog (Befehle und ihre Antworten) findet über eine Steuerverbindung zu Port 21 des Servers statt, und jede Übertragung einer Datei oder Dateiliste nutzt eine zweite Verbindung, die eigens dafür geöffnet wird. Hier ist ein typischer Dialog über die Steuerverbindung:

S: 220 FTP service ready
C: USER anonymous
S: 331 Please specify the password.
C: PASS guest@example.org
S: 230 Login successful.
C: PWD
S: 257 "/" is the current directory
C: EPSV
S: 229 Entering Extended Passive Mode (|||40312|)
C: RETR readme.txt
S: 150 Opening BINARY mode data connection for readme.txt (1250 bytes).
S: 226 Transfer complete.
C: QUIT
S: 221 Goodbye.
  • Zeile 2: anonyme Verbindung, wie sie öffentliche Download-Server anbieten;
  • Zeile 8: Der Client bittet den Server, einen Port für die Datenverbindung zu öffnen. Der Server antwortet (Zeile 9), dass er auf Port 40312 auf diese Verbindung wartet;
  • Zeile 10: Der Client fordert die Datei [readme.txt] an. Die Datei trifft über die Datenverbindung ein, und die Steuerverbindung empfängt die Antworten 150 (Beginn der Übertragung) und 226 (Ende der Übertragung).

Diese Befehle lassen sich im Protokoll eines Clients wie FTP oder FileZilla einsehen. FTP wird jedoch zunehmend obsolet: Es überträgt Passwörter im Klartext, arbeitet wegen seiner zweiten Verbindung nur schwer mit Firewalls zusammen, und Browser unterstützen es seit 2021 nicht mehr (Chrome 88, Firefox 90). Vorzuziehen sind SFTP, die Dateiübertragung über SSH, sowie das einfache Herunterladen über HTTPS.

12.5. Java-Klassen für die Webprogrammierung

12.5.1. Die passende Klasse auswählen

Java bietet verschiedene Klassen für die Arbeit mit dem Netzwerk:

Image

  • Die Klasse [Socket] (Paket [java.net]) repräsentiert ein Ende einer TCP-Verbindung. Der englische Begriff „socket“ bezeichnet eine Steckdose; seine Bedeutung wurde auf den Software-Netzwerk-Socket erweitert. Bei einer TCP/IP-Kommunikation zwischen zwei Rechnern A und B kommunizieren zwei Sockets miteinander. Ein Client erzeugt einen [Socket] , um sich mit einem Server zu verbinden; ein Server erzeugt einen [ServerSocket], der auf Verbindungsanfragen wartet und für jeden akzeptierten Client einen mit diesem Client verbundenen [Socket] bereitstellt. Sobald die Verbindung hergestellt ist, stellt ein [Socket] zwei Byte-Streams bereit – einen zum Lesen und einen zum Schreiben –, die wie Datei-Streams verwendet werden. Das ist bei Anwendung A oben der Fall;
  • Die Klasse [DatagramSocket] ermöglicht das Senden und Empfangen von UDP-Datagrammen. Wir verwenden sie in diesem Kurs nicht;
  • Die Klassen [SSLSocket] und [SSLServerSocket] (Paket [javax.net.ssl]) ergänzen [Socket] um die TLS-Verschlüsselung: Sobald die TLS-Aushandlung abgeschlossen ist, werden sie genau wie gewöhnliche Sockets verwendet (Anwendung B oben);
  • Java stellt außerdem eine auf ein Protokoll spezialisierte Klasse bereit: [HttpClient] (Paket [java.net.http], Java 11), die das HTTP-Protokoll in den Versionen 1.1 und 2 verarbeitet, einschließlich der TLS-Verschlüsselung von HTTPS (Anwendung C oben). Sie ersetzt die Klasse [HttpURLConnection] aus Java 1.1; wir kommen im zweiten Teil dieses Kapitels darauf zurück. Das JDK besitzt keine Klasse für E-Mail; hierfür wird die Bibliothek Jakarta Mail verwendet.

Die Klassen [Socket] und [ServerSocket] gibt es seit Java 1.0. Ihre Operationen sind blockierend: [accept] blockiert den aufrufenden Thread, bis ein Client eintrifft; eine Leseoperation blockiert ihn, bis Daten eintreffen. Java 1.4 hat das Paket [java.nio.channels] ([SocketChannel], [ServerSocketChannel], [Selector]) hinzugefügt, das nicht blockierende Operationen ermöglicht, und Java 7 hat asynchrone Kanäle eingeführt ([AsynchronousSocketChannel]). Darauf kommen wir am Ende dieses Kapitels vor der Beispielanwendung zurück: Seit der Einführung virtueller Threads (Java 21) genügen in den meisten Fällen die einfacheren Klassen [Socket] und [ServerSocket]. Diese verwenden wir.

12.5.2. Die Klasse Socket

Die Klasse [Socket] ist in den meisten Fällen die geeignete Wahl, um einen Client für einen TCP-Dienst zu erstellen. Zu ihren Konstruktoren und Methoden gehören unter anderem die folgenden:

Member
Typ
Rolle
Socket(String machine, int port)
C
Stellt eine TCP-Verbindung mit dem Dienst her, der auf Port [port] des Rechners [machine] läuft. Zum Beispiel [new Socket("localhost", 27100)]. Löst eine [UnknownHostException] aus, wenn der Rechner unbekannt ist, und eine [ConnectException] , wenn die Verbindung abgelehnt wird (dies sind zwei [IOException]s)
Socket(), void connect(SocketAddress address, int timeout)
C, M
erzeugt einen nicht verbundenen Socket und verbindet ihn dann, wobei höchstens [timeout] Millisekunden gewartet wird: Ohne Timeout kann der Verbindungsaufbau zu einem Rechner, der nicht antwortet, mehrere zehn Sekunden dauern
InputStream getInputStream(), OutputStream getOutputStream()
M
die Lese- und Schreib-Byte-Streams der Verbindung. Sie ermöglichen die Client-Server-Kommunikation
SocketAddress getLocalSocketAddress(), getRemoteSocketAddress()
M
die beiden Enden der Verbindung (Adresse und Port)
void setSoTimeout(int delay)
M
maximale Wartezeit für eine Leseoperation in Millisekunden: Wird sie überschritten, löst die Leseoperation eine [SocketTimeoutException] aus (0, der Standardwert, bedeutet „kein Timeout“)
void shutdownOutput()
M
Schließt nur den Schreib-Stream: Der Partner sieht das Ende des Streams, aber seine Antwort kann weiterhin gelesen werden
void close(), boolean isClosed()
M
schließt die Verbindung und ihre beiden Streams; [Socket] implementiert [AutoCloseable] und wird daher in einem [try] mit Ressourcen verwendet. Eine laufende Leseoperation in einem anderen Thread wird dann mit einer [SocketException] beendet

Die Streams von [getInputStream] und [getOutputStream] lesen und schreiben Bytes. Viele Client-Server-Anwendungen tauschen Textzeilen aus. Daher ist es sinnvoll, sie in Objekte der Klassen [BufferedReader] und [PrintWriter] zu verpacken, die in Kapitel 5 eingeführt wurden, um diese Zeilen zu lesen und zu schreiben. So verbindet sich der Echo-Client, den wir später schreiben ([Internet05.java]), und erzeugt seine Streams:

1
2
3
4
5
    // Verbindung zum Dienst, dann Lese- und Schreib-Streams auf der Verbindung
    try (var client = new Socket(server, port);
         var reader = new BufferedReader(new InputStreamReader(client.getInputStream(), UTF_8));
         // autoFlush: jede von println geschriebene Zeile wird sofort im Netzwerk gesendet
         var writer = new PrintWriter(client.getOutputStream(), true, UTF_8)) {
  • Zeile 2: Verbindung zum Server. Das [try] mit Ressourcen schließt die Verbindung und die Streams beim Verlassen des Blocks, was auch immer geschieht;
  • Zeile 3: Der Netzwerk-Stream wird in einen Zeichenstrom umgewandelt ([InputStreamReader]), der dann in einen [BufferedReader] verpackt wird, der eine Zeile lesen kann. Der Zeichensatz wird stets angegeben: Beide Seiten müssen sich über die Codierung der ausgetauschten Zeichen einig sein. Seit Java 18 ist UTF-8 der Standardzeichensatz, doch die ausdrückliche Angabe macht das Programm unabhängig von der Konfiguration des Rechners;
  • Zeile 5: Der zweite Parameter ([true]) des Konstruktors [PrintWriter] aktiviert das automatische Leeren (Flushen) des Puffers („autoFlush“): Jeder Aufruf von [println] überträgt die Zeile sofort ins Netzwerk, ohne zu warten, bis sich der interne Puffer füllt. Das ist wichtig. In der Regel erwartet ein Client, der seinem Partner eine Textzeile sendet, eine Antwort. Diese Antwort trifft nie ein, wenn die Zeile im Puffer des sendenden Rechners bleibt, ohne gesendet zu werden. Ohne autoFlush müssen Sie nach dem Schreiben einer vollständigen Anfrage ausdrücklich [flush] aufrufen.

Um eine Textzeile an den Server zu senden, schreiben Sie [writer.println("some text");], und um die Antwort des Servers zu lesen, schreiben Sie [String response = reader.readLine();]. [readLine] liefert [null] , wenn der Partner die Verbindung geschlossen hat und alles, was er gesendet hat, gelesen wurde: Das markiert das Ende des Streams.

Drei Punkte verdienen Beachtung:

  • das Zeilenende. [println] beendet die Zeile mit dem Zeilentrenner des Systems ([System.lineSeparator()]), der unter Windows \r\n lautet, unter Linux und macOS aber nur \n. Internetprotokolle (HTTP, SMTP, POP, FTP) verlangen \r\n. Manche Server tolerieren ein einzelnes \n, andere nicht; ein portables Programm, das eines dieser Protokolle verwendet, muss die Zeilenenden daher selbst schreiben: [writer.write(line + "\r\n")]. Beim Lesen akzeptiert [readLine] \r\n, \n und \r gleichermaßen;
  • Schreibfehler. Die Methoden von [PrintWriter] lösen niemals eine [IOException] aus: Ein Fehler wird lediglich vermerkt, und die Methode [checkError] zeigt an, ob einer aufgetreten ist. Für einen Dialog nach dem Muster „eine Anfrage, eine Antwort“ ist das unproblematisch: Eine getrennte Verbindung wird beim Lesen der Antwort erkannt. Wenn Schreibfehler gemeldet werden müssen, verwenden wir [BufferedWriter] oder [OutputStreamWriter], deren Methoden [write] und [flush] eine [IOException] auslösen;
  • Blockierende Operationen. [new Socket(...)], [readLine], und [println] blockieren den Thread, der sie ausführt, bis die Operation abgeschlossen ist. Für einen Client, der nichts anderes zu tun hat, als auf eine Antwort des Servers zu warten, ist genau das richtig. Muss er zwei Dinge gleichzeitig tun (zum Beispiel von der Tastatur und aus dem Netzwerk lesen), wird eine dieser Aufgaben an einen anderen Thread delegiert, wie wir es beim generischen TCP-Client tun werden.

Die grundlegende Architektur eines TCP-Clients mit dem folgenden einfachen Kommunikationsprotokoll mit dem Server:

  • Der Client sendet eine Anfrage, die in einer einzigen Zeile enthalten ist;
  • der Server sendet eine Antwort, die in einer einzigen Zeile enthalten ist;

sieht daher wie folgt aus: Socket und die beiden Streams in einem [try] mit Ressourcen öffnen, dann „Anfrage per [println] senden, Antwort per [readLine] lesen“ bis zum Ende des Dialogs wiederholen und dabei die [IOException]-Meldungen abfangen: Eine [UnknownHostException] oder eine [ConnectException] zeigt eine fehlgeschlagene Verbindung an (unbekannter Rechner, kein Dienst auf dem angeforderten Port usw.), während eine [IOException] einen Fehler während der Kommunikation anzeigt (Verbindung verloren usw.). Das ist die Struktur des Echo-Clients, den wir im Abschnitt [A Client for the Echo Server] beschreiben werden.

12.5.3. Die Klasse ServerSocket

Die Klasse [ServerSocket] ist in den meisten Fällen die geeignete Klasse, um einen TCP-Dienst zu erstellen. Zu ihren Konstruktoren und Methoden gehören unter anderem die folgenden:

Member
Typ
Rolle
ServerSocket(int port)
C
erzeugt einen TCP-Dienst, der auf Port [port] – den sogenannten Listening-Port – auf Client-Anfragen von allen Adressen des Rechners (IPv4 und IPv6) lauscht. Löst eine [BindException] aus, wenn der Port bereits belegt ist
ServerSocket(int port, int backlog, InetAddress address)
C
Ebenso, jedoch nur auf der Adresse [address] lauschend (zum Beispiel der Loopback-Adresse, um nur Clients des lokalen Rechners zu akzeptieren). [backlog] ist die maximale Anzahl wartender, noch nicht akzeptierter Verbindungsanfragen (standardmäßig 50)
Socket accept()
M
wartet auf eine Client-Anfrage und akzeptiert sie. Liefert den [Socket] , der serverseitig mit der offenen Dienstverbindung zu diesem Client verknüpft ist
void close()
M
beendet das Lauschen auf Client-Anfragen; ein in einem anderen Thread gerade laufendes [accept] wird durch eine [SocketException] beendet
SocketAddress getLocalSocketAddress()
M
die Adresse und der Port, auf denen gelauscht wird

Hier die Grundstruktur eines TCP-Servers, entnommen dem Echo-Server, den wir später schreiben ([Internet04.java]):

    // der lauschende Dienst, auf allen Netzwerkschnittstellen des Rechners
    try (var listener = new ServerSocket(port);
         // ein virtueller Thread pro Client; close() wartet auf das Ende aller Dienste
         var services = Executors.newVirtualThreadPerTaskExecutor()) {
        // Ctrl-C: der Server stoppt sauber
        stopOnCtrlC(listener);
        IO.println("Echo server started on " + listener.getLocalSocketAddress());
        try {
            // Schleife, die auf Clients wartet - durch Ctrl-C gestoppt
            for (int clientNum = 0; ; clientNum++) {
                // (blockierendes) Warten auf einen Client
                Socket client = listener.accept();
                connections.add(client);
                // der Client wird von einem virtuellen Thread bedient; wir gehen sofort wieder zum Warten auf den nächsten über
                int number = clientNum;
                services.submit(() -> serve(client, number));
            }
  • Zeile 2: Der lauschende Dienst wird für einen bestimmten Port erzeugt. Ein Rechner hat mindestens zwei IP-Adressen: die Loopback-Adresse 127.0.0.1 und die Adresse, die er in dem Netzwerk hat, mit dem er verbunden ist. Wenn er mit mehreren Netzwerken verbunden ist, kann er weitere haben. Solange keine Adresse angegeben wird, lauscht der Dienst auf allen diesen Adressen. Sobald er erzeugt ist, beginnt der Dienst zu lauschen – das heißt, auf Verbindungsanfragen von Clients zu warten;
  • Zeile 4: ein [ExecutorService] (Kapitel 8), der für jede ihm übergebene Aufgabe einen virtuellen Thread erzeugt. Er ist ebenfalls in der [try] -mit-Ressourcen-Anweisung deklariert: Seine Methode [close] wartet, bis alle übergebenen Aufgaben abgeschlossen sind;
  • Zeilen 10–17: die Schleife, die auf einen Client wartet und dessen Service startet und für jeden neuen Client wiederholt wird;
  • Zeile 12: Die Anfrage eines Clients wird angenommen. [accept] liefert einen sogenannten Service-[Socket]:
    • Der Client hat seine Anfrage über seinen eigenen [Socket] gestellt, den wir [RequestSocket] nennen;
    • der Server nimmt diese Anfrage mit [accept] an, was einen serverseitigen [Socket] erzeugt, den wir [ServiceSocket] nennen. Damit besteht eine offene TCP-Verbindung mit den Sockets [RequestSocket] ↔ [ServiceSocket] an beiden Enden;
    • die Client-Server-Kommunikation, die anschließend stattfindet, läuft über diese Verbindung. Der lauschende Service ist daran nicht mehr beteiligt;
  • Zeile 16: Damit der Server mehrere Clients gleichzeitig bedienen kann, wird der Service von einem virtuellen Thread abgewickelt. Der Server wartet nicht darauf, sondern kehrt sofort zurück, um auf den nächsten Client zu warten. Das an [submit] übergebene Lambda darf nur lokale Variablen verwenden, deren Wert sich nicht mehr ändert („effektiv final“): Die Schleifenvariable [clientNum] wird deshalb in die Variable [number] kopiert (Zeile 15).

Die Methode [serve], die vom virtuellen Thread ausgeführt wird, erhält den [Socket] , der bereits mit dem zu bedienenden Client verbunden ist. Der Code ähnelt hier dem des TCP-Clients: Erzeugung der Datenströme, gefolgt von einer Schleife, die „eine Anfrage über [readLine] liest und die Antwort über [println] schreibt“, bis [readLine] den Wert [null] zurückgibt, also bis der Client die Verbindung schließt. Ausnahmen müssen in dieser Methode abgefangen werden: Niemand wartet auf das Ergebnis des Service-Threads, und eine dort nicht abgefangene Ausnahme bliebe unbemerkt (sie würde lediglich in der Fehlerausgabe angezeigt).

12.5.4. Ein Thread pro Client: Plattform-Threads oder virtuelle Threads?

Vor Java 21 wies ein Server jeden Client einem Plattform-Thread – also einem Thread des Betriebssystems – oder einem Thread aus einem Pool fester Größe zu ([Executors.newFixedThreadPool]). Dieser Thread führte blockierende Lese- und Schreibvorgänge aus: Solange der Client „nachdachte“, blieb sein Thread untätig in [readLine]. Jeder Plattform-Thread verbraucht Speicher (ein reservierter Stack von etwa 1 MB) und Prozessorzeit des Systems, das zwischen den Threads wechseln muss. Bei einigen Dutzend Clients ist das kein Problem; bei Tausenden gleichzeitigen Verbindungen – ein für einen realen Server üblicher Fall – bricht der Server zusammen. Bei einem auf 10 Threads begrenzten Pool muss der elfte Client warten, bis sich einer der ersten zehn abmeldet.

Um diese Einschränkung zu umgehen, musste man lange auf blockierende Operationen verzichten: auf die nicht blockierenden Kanäle in [java.nio] und deren [Selector], mit denen ein einzelner Thread mehrere Verbindungen überwachen kann, oder auf die asynchronen Kanäle aus Java 7, die am Ende jeder Operation eine Callback-Methode aufrufen. Diese Techniken sind effizient, aber schwierig zu programmieren: Die Dialoglogik verteilt sich auf mehrere Methoden. Sie bilden die Grundlage von Bibliotheken wie Netty, die in vielen Servern eingesetzt werden.

Virtuelle Threads (Java 21, Kapitel 8) haben alles verändert. Ein virtueller Thread wird von der Java Virtual Machine verwaltet, nicht vom Betriebssystem. Führt er eine blockierende Netzwerkoperation aus, wird er von seinem Trägerthread „gelöst“, der dann einen anderen virtuellen Thread ausführen kann; sobald die Daten eintreffen, wird er wieder an einen Trägerthread gebunden. Einige wenige Trägerthreads – so viele, wie der Prozessor Kerne hat – genügen somit, um Tausende von Clients zu bedienen, und ein Client, der nichts sendet, verbraucht fast nichts: nur einige hundert Bytes Stack. Der Code selbst bleibt derselbe einfache, sequenzielle Code wie beim Modell „ein Thread pro Client“. Dieses Modell verwenden wir in allen Servern dieses Kapitels: [ServerSocket.accept] im Haupt-Thread, mit einem virtuellen Thread pro Client.

12.6. Beispiele für TCP-Clients und -Server

Die Programme dieses Abschnitts sind kompakte Quelldateien im Ordner [12-internet], die mit dem Source-Code-Launcher ([java Internet04.java ...]) ausgeführt werden. Die Server und Clients werden in getrennten Eingabeaufforderungsfenstern auf demselben Rechner gestartet; die verwendeten Ports haben die Form 271xx.

12.6.1. Ein Echo-Server

Wir schreiben einen Echo-Server, der in einem Eingabeaufforderungsfenster wie folgt gestartet wird:

java Internet04.java port

Der Server läuft auf dem als Argument übergebenen Port. Er sendet dem Client einfach jede Zeile, die dieser ihm schickt, in eckige Klammern eingeschlossen zurück. Das Programm [Internet04.java] lautet wie folgt:

import static java.nio.charset.StandardCharsets.UTF_8;

// Echo-Server: sendet jedem Client die Zeilen zurück, die der Client ihm sendet
// jeder Client wird von einem virtuellen Thread bedient
// Aufruf: java Internet04.java port; Stopp mit Ctrl-C

final String SYNTAX = "Syntax: java Internet04.java port";

// die laufenden Dienstverbindungen, beim Stopp des Servers geschlossen
final Set<Socket> connections = ConcurrentHashMap.newKeySet();
// wurde der Stopp des Servers angefordert?
volatile boolean stop = false;

void main(String[] args) {
    // ein Argument ist erforderlich: ein Port zwischen 1 und 65535
    int port = args.length == 1 ? integer(args[0]) : -1;
    if (port < 1 || port > 65535) {
        IO.println(SYNTAX);
        return;
    }
    // der lauschende Dienst, auf allen Netzwerkschnittstellen des Rechners
    try (var listener = new ServerSocket(port);
         // ein virtueller Thread pro Client; close() wartet auf das Ende aller Dienste
         var services = Executors.newVirtualThreadPerTaskExecutor()) {
        // Ctrl-C: der Server stoppt sauber
        stopOnCtrlC(listener);
        IO.println("Echo server started on " + listener.getLocalSocketAddress());
        try {
            // Schleife, die auf Clients wartet - durch Ctrl-C gestoppt
            for (int clientNum = 0; ; clientNum++) {
                // (blockierendes) Warten auf einen Client
                Socket client = listener.accept();
                connections.add(client);
                // der Client wird von einem virtuellen Thread bedient; wir gehen sofort wieder zum Warten auf den nächsten über
                int number = clientNum;
                services.submit(() -> serve(client, number));
            }
        } catch (SocketException e) {
            // accept schlägt fehl, wenn Ctrl-C den lauschenden Dienst schließt
            if (!stop) {
                throw e;
            }
            IO.println("Server stop requested");
            // die laufenden Verbindungen werden geschlossen: die Dienste stoppen
            for (Socket connection : connections) {
                connection.close();
            }
        }
    } catch (IOException e) {
        IO.println("The following error occurred on the server: " + e.getMessage());
    }
}

// Ctrl-C: Schließen des lauschenden Dienstes, dann Warten auf das Ende des Hauptprogramms
void stopOnCtrlC(ServerSocket listener) {
    Thread main = Thread.currentThread();
    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
        stop = true;
        try {
            listener.close();
            // die virtuelle Maschine stoppt am Ende dieses Threads: wir warten auf das Ende des Haupt-Threads
            main.join();
        } catch (IOException | InterruptedException e) {
            // wir stoppen trotzdem
        }
    }));
}

// der einem Client erbrachte Dienst
void serve(Socket client, int clientNum) {
    IO.println("Start of service to client " + clientNum + " (" + client.getRemoteSocketAddress() + ")");
    // die Verbindung und ihre Streams werden beim Verlassen des try geschlossen
    try (client;
         var reader = new BufferedReader(new InputStreamReader(client.getInputStream(), UTF_8));
         var writer = new PrintWriter(client.getOutputStream(), true, UTF_8)) {
        // Schleife Anfrage lesen / Antwort schreiben
        // readLine liefert null, wenn der Client die Verbindung schließt
        String request;
        while ((request = reader.readLine()) != null) {
            IO.println("<--- client " + clientNum + " : " + request);
            // Echo der Anfrage an den Client, in eckigen Klammern
            writer.println("[" + request + "]");
            IO.println("---> client " + clientNum + " : [" + request + "]");
        }
    } catch (IOException e) {
        if (stop) {
            IO.println("Service to client " + clientNum + " interrupted by the server stop");
        } else {
            IO.println("The following error occurred while serving client " + clientNum + ": "
                    + e.getMessage());
        }
    } finally {
        connections.remove(client);
        IO.println("End of service to client " + clientNum);
    }
}

// eine ganze Zahl oder -1, wenn die Zeichenkette keine ist
int integer(String string) {
    try {
        return Integer.parseInt(string);
    } catch (NumberFormatException e) {
        return -1;
    }
}

Die Struktur des Echo-Servers entspricht der zuvor beschriebenen Grundarchitektur von TCP-Servern, mit einigen Ergänzungen:

  • Zeilen 10 und 12: zwei Felder der impliziten Klasse der kompakten Quelldatei. Die Menge [connections] enthält die aktuellen Service-Verbindungen; mehrere Threads fügen gleichzeitig Elemente hinzu und entfernen sie, es handelt sich daher um eine für den nebenläufigen Zugriff gedachte Menge, die über [ConcurrentHashMap.newKeySet()] bezogen wird (Kapitel 8). Der boolesche Wert [stop] gibt an, ob das Herunterfahren des Servers angefordert wurde; er ist als [volatile] deklariert, weil er von einem Thread geändert und von anderen gelesen wird;
  • Zeilen 16–20: Der Port muss eine ganze Zahl zwischen 1 und 65.535 sein. Die Methode [integer] (Zeilen 99–105) gibt -1 zurück, wenn das Argument keine ganze Zahl ist;
  • Zeilen 22–24: der lauschende Service und die [ExecutorService]-Methode, die für jeden Client einen virtuellen Thread erzeugt;
  • Zeile 26: Der Server wird heruntergefahren. Strg+C löst nicht, wie ein Ereignishandler, eine vom Programm gewählte Methode aus, sondern beendet die virtuelle Maschine. Vor dem Beenden führt die virtuelle Maschine jedoch die „Shutdown-Hooks“ aus, die mit [Runtime.getRuntime().addShutdownHook] registriert wurden. Unser Hook (Zeilen 55–67) ist ein Thread, der erkennt, dass ein Herunterfahren angefordert wurde (Zeile 58), den lauschenden Service schließt (Zeile 60) und dann auf das Ende des Haupt-Threads wartet (Zeile 62): Die virtuelle Maschine fährt tatsächlich erst herunter, sobald die Hooks abgeschlossen sind;
  • Zeile 32: Das Schließen des lauschenden Service lässt das Warten auf einen Client fehlschlagen, wodurch eine [SocketException] ausgelöst wird, die in Zeile 38 abgefangen wird. Wurde das Herunterfahren nicht angefordert, handelt es sich um einen echten Fehler: Die Ausnahme wird erneut ausgelöst (Zeile 41), damit sie vom [catch] in Zeile 49 behandelt werden kann;
  • Zeilen 43–47: Alle aktiven Service-Verbindungen werden geschlossen: Die Service-Threads, die in einem Lesevorgang blockiert sind, erhalten eine [SocketException] und werden beendet. Beim Verlassen der [try] -mit-Ressourcen-Anweisung wartet die Methode [close] des [ExecutorService] , bis alle Services beendet sind, bevor die Methode [main] endet.

Der Abschnitt „Kundendienst“:

  • Zeile 71: die Adresse und der Port des Clients;
  • Zeilen 73–75: der Socket des Clients, der zu Beginn der [try]-mit-Ressourcen-Anweisung deklariert wird (Java 9 akzeptiert eine zuvor deklarierte Variable), sowie die Lese- und Schreibströme der Verbindung;
  • Zeile 79: Die Anfrage des Clients wird gelesen. [readLine] gibt [null] zurück, wenn der Client die Verbindung schließt: Die Schleife und der Service werden dann beendet;
  • Zeile 82: Die Anfrage wird in eckige Klammern eingeschlossen an den Client zurückgesendet;
  • Zeilen 85–91: Eine [IOException] zeigt entweder an, dass der Server heruntergefahren wurde – wobei er die Verbindung während des Lesens geschlossen hat –, oder dass der Client die Verbindung beendet hat;
  • Zeilen 92–95: Der [finally]-Block entfernt die Verbindung unabhängig von der Ursache aus der Liste der aktiven Verbindungen und signalisiert das Ende des Service.

Um den Server in Aktion zu sehen, benötigen wir einen Client. Wir schreiben ihn im nächsten Abschnitt und stellen anschließend die Ergebnisse vor.

12.6.2. Ein Client für den Echo-Server

Wir schreiben nun einen Client für den vorherigen Server. Er wird wie folgt aufgerufen:

java Internet05.java machine port

Er verbindet sich mit dem Rechner [machine] auf dem Port [port] und sendet dann die über die Tastatur eingegebenen Textzeilen an den Server, der sie zurückschickt. Das Programm [Internet05.java] lautet wie folgt:

import static java.nio.charset.StandardCharsets.UTF_8;

// Echo-Client: sendet die über die Tastatur eingegebenen Zeilen an den Server
// und zeigt die Antworten des Servers an
// Aufruf: java Internet05.java machine port

final String SYNTAX = "Syntax: java Internet05.java machine port";

void main(String[] args) {
    int port = args.length == 2 ? integer(args[1]) : -1;
    if (port < 1 || port > 65535) {
        IO.println(SYNTAX);
        return;
    }
    String server = args[0];

    // Verbindung zum Dienst, dann Lese- und Schreib-Streams auf der Verbindung
    try (var client = new Socket(server, port);
         var reader = new BufferedReader(new InputStreamReader(client.getInputStream(), UTF_8));
         // autoFlush: jede von println geschriebene Zeile wird sofort im Netzwerk gesendet
         var writer = new PrintWriter(client.getOutputStream(), true, UTF_8)) {
        IO.println("Connected to the server " + client.getRemoteSocketAddress() + " from "
                + client.getLocalSocketAddress());
        // Anfrage-Antwort-Schleife
        while (true) {
            // die Anfrage kommt von der Tastatur
            String request = IO.readln("Request (bye to stop): ");
            // fertig?
            if (request == null || request.strip().equalsIgnoreCase("bye")) {
                break;
            }
            // die Anfrage wird an den Server gesendet
            writer.println(request);
            // wir warten auf seine Antwort
            String response = reader.readLine();
            if (response == null) {
                IO.println("The server closed the connection");
                break;
            }
            IO.println("Response: " + response);
        }
    } catch (IOException e) {
        IO.println("The following error occurred: " + e.getClass().getSimpleName()
                + " (" + e.getMessage() + ")");
    }
}

// eine ganze Zahl oder -1, wenn die Zeichenkette keine ist
int integer(String string) {
    try {
        return Integer.parseInt(string);
    } catch (NumberFormatException e) {
        return -1;
    }
}

Die Struktur dieses Clients entspricht der für TCP-Clients vorgeschlagenen Grundarchitektur:

  • Zeilen 18–21: Verbindung zum Server und Erzeugung der Datenströme, wie bereits besprochen;
  • Zeilen 22–23: Die beiden Enden der Verbindung werden angezeigt: [getRemoteSocketAddress] (der Server) und [getLocalSocketAddress] (der Client). Der Port des Clients wurde vom System gewählt;
  • Zeile 27: Die Anfrage wird über die Tastatur eingegeben. [IO.readln] gibt [null] zurück, wenn die Standardeingabe geschlossen ist (Strg+D unter Linux, Strg+Z gefolgt von Enter unter Windows);
  • Zeile 29: Der Vergleich mit [bye] ignoriert die Groß- und Kleinschreibung;
  • Zeile 33: Die Anfrage wird an den Server gesendet;
  • Zeilen 35–39: Es wird auf die Antwort gewartet; [null] zeigt an, dass der Server die Verbindung geschlossen hat;
  • Zeilen 42–45: Verbindungs- und Austauschfehler.

Hier sind die Ergebnisse mit der folgenden Konfiguration:

  • Der Server läuft auf Port 27100 in einem Eingabeaufforderungsfenster;
  • auf demselben Rechner laufen zwei Clients, A und B, in zwei weiteren Fenstern; B wurde gestartet, während A noch mit dem Server kommunizierte.

Im Fenster von Client A:

1
2
3
4
5
6
7
8
9
> java Internet05.java localhost 27100
Connected to the server localhost/127.0.0.1:27100 from /127.0.0.1:47902
Request (bye to stop): line1A
Response: [line1A]
Request (bye to stop): line2A
Response: [line2A]
Request (bye to stop): line3A
Response: [line3A]
Request (bye to stop): bye

Client A hat drei Zeilen gesendet, die zurückgeschickt wurden, und dann [bye] eingegeben: Er hat die Verbindung geschlossen, ohne dem Server etwas zu senden.

Im Fenster von Client B:

1
2
3
4
5
6
7
8
> java Internet05.java localhost 27100
Connected to the server localhost/127.0.0.1:27100 from /127.0.0.1:45096
Request (bye to stop): line1B
Response: [line1B]
Request (bye to stop): line2B
Response: [line2B]
Request (bye to stop): line3B
The server closed the connection

Client B hat zwei Zeilen gesendet, und dann, noch vor der Eingabe der dritten, wurde der Server mit Strg+C beendet. Die Zeile [line3B] wurde über eine Verbindung gesendet, die der Server bereits geschlossen hatte: Das Lesen der Antwort (Zeile 8 der Ergebnisse) lieferte [null].

Im Serverfenster:

> java Internet04.java 27100
Echo server started on 0.0.0.0/0.0.0.0:27100
Start of service to client 0 (/127.0.0.1:47902)
<--- client 0 : line1A
---> client 0 : [line1A]
Start of service to client 1 (/127.0.0.1:45096)
<--- client 0 : line2A
---> client 0 : [line2A]
<--- client 1 : line1B
---> client 1 : [line1B]
<--- client 0 : line3A
---> client 0 : [line3A]
<--- client 1 : line2B
---> client 1 : [line2B]
End of service to client 0
Server stop requested
Service to client 1 interrupted by the server stop
End of service to client 1
  • Zeile 2: Der Server lauscht auf Port 27100 auf allen Adressen des Rechners, dargestellt durch die Wildcard-Adresse 0.0.0.0;
  • Zeilen 3 und 6: Beide Clients haben sich vom selben Rechner (127.0.0.1) mit unterschiedlichen, vom System zugewiesenen Ports verbunden. Diese Ports unterscheiden die beiden Verbindungen, die beide am Port 27100 des Servers enden;
  • Zeile 6: Client 1 (B) wird bedient, während Client 0 (A) noch bedient wird, und die Zeilen 7–14 zeigen, dass ihre Anfragen jeweils bei Eingang verarbeitet werden: Der Server bedient tatsächlich mehrere Clients gleichzeitig;
  • Zeile 15: Der Server hat erkannt, dass Client A die Verbindung geschlossen hat;
  • Zeilen 16–18: Im Serverfenster wurde Strg+C gedrückt. Der Versuch, auf einen neuen Client zu warten, schlug fehl, und anschließend wurde der Service für Client 1 – der auf eine Zeile wartete – unterbrochen, als seine Verbindung geschlossen wurde. Der Server wurde ordnungsgemäß heruntergefahren.

So verhält es sich, wenn Sie versuchen, sich mit einem Port zu verbinden, auf dem kein Service lauscht:

> java Internet05.java localhost 27199
The following error occurred: ConnectException (Connection refused)

Der [Socket]-Konstruktor hat eine [ConnectException] ausgelöst: Der Rechner hat geantwortet, aber kein Programm lauscht auf Port 27199. Die Meldung stammt vom Betriebssystem; unter Windows lautet sie anders.

Wenn Sie den Server schließlich auf einem bereits belegten Port starten – zum Beispiel in einem zweiten Fenster, während der erste Server noch läuft –, schlägt die Erzeugung des [ServerSocket] fehl:

> java Internet04.java 27100
The following error occurred on the server: Address already in use

12.6.3. Ein generischer TCP-Client

Wir schreiben einen generischen TCP-Client, der wie folgt gestartet wird:

java Internet06.java machine port

Er funktioniert ähnlich wie die Clients [telnet] und PuTTY: Er ermöglicht die Kommunikation mit jedem textbasierten TCP-Server.

Im vorherigen Beispiel war das Kommunikationsprotokoll bekannt: Der Client sendete eine einzelne Zeile, und der Server antwortete mit einer einzelnen Zeile. Jeder Service hat sein eigenes Protokoll, und es können außerdem folgende Situationen auftreten:

  • Der Client muss mehrere Textzeilen senden, bevor er eine Antwort erhält (eine HTTP-Anfrage);
  • die Antwort eines Servers kann aus mehreren Textzeilen bestehen (die Antwort [EHLO] eines SMTP-Servers, ein HTML-Dokument);
  • der Server kann zuerst sprechen (die Willkommensnachricht von SMTP- und POP-Servern).

Der Zyklus „eine einzelne Zeile an den Server senden / eine einzelne vom Server gesendete Zeile empfangen“ ist daher nicht immer geeignet. Um Protokolle zu verarbeiten, die komplexer sind als das Echo-Protokoll, führt der generische TCP-Client zwei Aktivitäten parallel in zwei Threads aus:

  • Ein virtueller Thread liest die über die Tastatur eingegebenen Textzeilen und sendet sie an den Server;
  • der Haupt-Thread liest die vom Server gesendeten Textzeilen. Sobald er eine empfängt, zeigt er sie auf der Konsole an. Er hört erst auf, wenn die Verbindung geschlossen wird.

Das Programm [Internet06.java] lautet wie folgt:

import static java.nio.charset.StandardCharsets.UTF_8;

// generischer TCP-Client
// - verbindet sich mit dem Dienst (Rechner, Port)
// - ein virtueller Thread sendet jede über die Tastatur eingegebene Zeile an den Server
// - der Haupt-Thread zeigt fortlaufend die vom Server gesendeten Zeilen an
// Aufruf: java Internet06.java machine port

final String SYNTAX = "Syntax: java Internet06.java machine port";
// Ende über die Tastatur angefordert (bye)?
volatile boolean end = false;

void main(String[] args) {
    int port = args.length == 2 ? integer(args[1]) : -1;
    if (port < 1 || port > 65535) {
        IO.println(SYNTAX);
        return;
    }
    String server = args[0];

    // Verbindung zum Dienst
    Socket client;
    try {
        client = new Socket(server, port);
    } catch (IOException e) {
        IO.println("Unable to connect to the service (" + server + ", " + port + "): "
                + e.getMessage());
        return;
    }
    try (client;
         var reader = new BufferedReader(new InputStreamReader(client.getInputStream(), UTF_8));
         var writer = new OutputStreamWriter(client.getOutputStream(), UTF_8)) {
        IO.println("Type your commands (bye to stop):");
        // das Lesen der Tastaturbefehle wird einem virtuellen Thread übertragen
        Thread.ofVirtual().start(() -> input(client, writer));
        // der Haupt-Thread zeigt die Zeilen des Servers an, bis die Verbindung geschlossen wird
        String response;
        while ((response = reader.readLine()) != null) {
            IO.println("<-- " + response);
        }
        IO.println("[the server closed the connection]");
    } catch (IOException e) {
        // eine vom Eingabe-Thread (bye) geschlossene Verbindung ist kein Fehler
        if (!end) {
            IO.println("The following error occurred while reading: " + e.getMessage());
        }
    }
    // Ende des Haupt-Threads: der virtuelle Eingabe-Thread wird, falls er noch auf die Tastatur wartet, aufgegeben
}

// sendet die über die Tastatur eingegebenen Zeilen an den Server, bis bye
void input(Socket client, Writer writer) {
    try {
        while (true) {
            String command = IO.readln();
            // fertig?
            if (command == null || command.strip().equalsIgnoreCase("bye")) {
                break;
            }
            // die gesendeten Zeilen enden mit \r\n, wie von HTTP, SMTP, POP, FTP... verlangt
            writer.write(command + "\r\n");
            writer.flush();
        }
    } catch (IOException e) {
        IO.println("The following error occurred while writing: " + e.getMessage());
    } finally {
        // die Verbindung wird geschlossen: das laufende Lesen im Haupt-Thread endet
        end = true;
        try {
            client.close();
        } catch (IOException e) {
            // nichts zu tun
        }
    }
}

// eine ganze Zahl oder -1, wenn die Zeichenkette keine ist
int integer(String string) {
    try {
        return Integer.parseInt(string);
    } catch (NumberFormatException e) {
        return -1;
    }
}
  • Zeilen 23–29: Der Client verbindet sich mit dem Server;
  • Zeilen 30–32: Der Socket und seine Ströme werden geschlossen, wenn [try] verlassen wird. Der Schreibstrom ist ein einfacher [OutputStreamWriter], dessen Methoden im Fehlerfall eine [IOException] auslösen;
  • Zeile 35: Die Tastatureingabe wird von einem virtuellen Thread verarbeitet, der von [Thread.ofVirtual().start] (Java 21) erzeugt und gestartet wird und die Methode [input] (Zeilen 52–75) ausführt;
  • Zeilen 37–41: Währenddessen zeigt der Haupt-Thread jede vom Server gesendete Zeile an, der [<--] vorangestellt wird, bis zum Ende des Stroms (Zeile 41);
  • Zeilen 42–47: Wenn der Benutzer [bye] eingibt, schließt der Eingabe-Thread die Verbindung (Zeile 70); der laufende Lesevorgang im Haupt-Thread endet dann mit einer [SocketException]. Das ist kein Fehler: Das vom Eingabe-Thread gesetzte Feld [end] (Zeile 68) bestätigt dies;
  • Zeile 48: Wenn der Server die Verbindung schließt, endet der Haupt-Thread, während der Eingabe-Thread möglicherweise noch auf eine Zeile von der Tastatur wartet. Das ist kein Problem: Ein virtueller Thread ist immer ein „Daemon-Thread“, und die virtuelle Maschine stoppt, wenn alle Nicht-Daemon-Threads beendet sind – hier nur der Haupt-Thread. Anders als bei einem gewöhnlichen Thread ist es nicht nötig, den Eingabe-Thread zu stoppen;
  • Zeilen 55–63: Der Eingabe-Thread liest die über die Tastatur eingegebenen Zeilen und sendet sie an den Server. Die gesendeten Zeilen enden mit \r\n, wie es die Protokolle verlangen, die wir untersuchen möchten, und werden von [flush] sofort über das Netzwerk übertragen.

Wir können nun manuell eine HTTP-Anfrage an unseren Test-Webserver ([Internet03.java]) senden, der in einem anderen Fenster läuft. Die Zeilen, denen [<--] vorangestellt ist, wurden vom Server gesendet; die übrigen wurden über die Tastatur eingegeben:

> java Internet06.java localhost 27110
Type your commands (bye to stop):
GET /hello?name=Serge HTTP/1.1
Host: localhost:27110
Connection: close

<-- HTTP/1.1 200 OK
<-- Date: Sat, 03 Oct 2026 17:40:20 GMT
<-- Transfer-encoding: chunked
<-- Content-type: text/plain; charset=utf-8
<-- 
<-- c
<-- Hello Serge!
<-- 0
<-- 
[the server closed the connection]
  • Zeilen 3–5: die über die Tastatur eingegebene Anfrage: Wir fordern das Dokument [/hello?name=Serge] an. Der Header [Connection: close] weist den Server an, die Verbindung zu schließen, sobald seine Antwort gesendet wurde;
  • Zeile 6: Die Leerzeile beendet die Anfrage. Sie löst die Antwort des Servers aus;
  • Zeile 7: Das Dokument wurde gefunden;
  • Zeile 9: Der Server hat die Größe des Dokuments ([Content-length]) nicht angegeben; er sendet es in Chunks, denen jeweils ihre Größe in Hexadezimalschreibweise vorangestellt ist;
  • Zeile 10: Diesmal ist das Dokument reiner Text;
  • Zeilen 12–14: ein einzelner Chunk von 0x0c = 12 Bytes, der Text [Hello Serge!], gefolgt von einem Chunk der Größe null, der das Ende des Dokuments markiert;
  • Zeile 16: Wie angefordert hat der Server die Verbindung geschlossen. Der Client hat dies erkannt und sich von selbst beendet, ohne darauf zu warten, dass der Benutzer [bye] eingibt.

Versuchen wir es noch einmal ohne den Header [Connection: close] und fordern das Stammverzeichnis der Site an:

> java Internet06.java localhost 27110
Type your commands (bye to stop):
GET / HTTP/1.1
Host: localhost:27110

<-- HTTP/1.1 200 OK
<-- Date: Sat, 03 Oct 2026 17:40:23 GMT
<-- Content-type: text/html; charset=utf-8
<-- Content-length: 171
<-- 
<-- <!DOCTYPE html>
<-- <html lang="en">
<-- <head><meta charset="utf-8"><title>Test server</title></head>
<-- <body><h1>Welcome to the test server of the Java course</h1></body>
<-- </html>
bye
  • Zeile 9: Das Dokument wird zusammen mit seiner Größe von 171 Bytes angekündigt. Der Client weiß somit, wo es endet;
  • Zeilen 15–16: Das Dokument wurde vollständig empfangen, aber der Server hat die Verbindung nicht geschlossen: In HTTP/1.1 bleibt sie standardmäßig für weitere Anfragen offen. Der Server wartet auf eine neue Anfrage; der Benutzer gibt dann [bye] ein, um die Verbindung zu schließen.

Wenn der Server nicht verfügbar ist, schlägt die Verbindung fehl:

> java Internet06.java localhost 27199
Unable to connect to the service (localhost, 27199): Connection refused

Der Leser kann diesen generischen TCP-Client mit dem Echo-Server verwenden oder, wenn er einen SMTP- oder POP3-Server besitzt, der unverschlüsselte Verbindungen akzeptiert (etwa einen lokal installierten Testserver), die oben gezeigten Beispieldialoge nachvollziehen.

12.6.4. Ein generischer TCP-Server

Wir befassen uns nun mit einem Server,

  • der die von seinen Clients gesendeten Zeilen auf dem Bildschirm anzeigt;
  • der als Antworten die Textzeilen zurücksendet, die ein Benutzer über die Tastatur eingibt. Der Benutzer fungiert somit als Server.

Das Programm wird in einem Eingabeaufforderungsfenster mit [java Internet07.java port] gestartet, wobei [port] der Port ist, mit dem sich die Clients verbinden müssen. Die Clients werden nacheinander bedient, nicht parallel: Die Konsole kann nicht gleichzeitig für zwei Clients verwendet werden. Clients, die sich in dieser Zeit verbinden, erhalten ihre Verbindung vom System hergestellt, müssen aber warten, bis das Programm sie annimmt. Drei Aktivitäten laufen parallel ab:

  • Ein virtueller Thread liest während der gesamten Laufzeit des Programms die über die Tastatur eingegebenen Zeilen;
  • für jeden Client liest ein virtueller Thread die vom Client gesendeten Zeilen und zeigt sie an;
  • der Haupt-Thread nimmt Clients an und sendet die über die Tastatur eingegebenen Zeilen an den aktuellen Client. Mit dem Befehl [bye] signalisiert der Benutzer, dass er die Verbindung zum Client schließt.

Der Haupt-Thread muss also auf zwei Arten von Ereignissen warten: eine über die Tastatur eingegebene Zeile oder das Weggehen des Clients. Die beiden anderen Threads melden ihm diese Ereignisse, indem sie sie in eine blockierende Warteschlange stellen ([BlockingQueue], Kapitel 8), aus der er sie nacheinander entnimmt. Der Server wird nur beendet, wenn der Benutzer Strg+C auf der Tastatur drückt oder die Standardeingabe geschlossen wird. Das Programm [Internet07.java] lautet wie folgt:

import static java.nio.charset.StandardCharsets.UTF_8;

// generischer TCP-Server
// - zeigt die vom Client gesendeten Zeilen an
// - sendet ihm als Antworten die vom Benutzer über die Tastatur eingegebenen Zeilen
// die Clients werden nacheinander bedient (eine einzige Konsole)
// Aufruf: java Internet07.java port; Stopp mit Ctrl-C

final String SYNTAX = "Syntax: java Internet07.java port";

// die vom Hauptprogramm erwarteten Ereignisse
sealed interface Event permits Input, EndOfInput, ClientLeft {
}

// eine über die Tastatur eingegebene Zeile
record Input(String line) implements Event {
}

// Ende der Standardeingabe (Ctrl-D, Ctrl-Z)
record EndOfInput() implements Event {
}

// Client Nr. [clientNum] hat die Verbindung geschlossen
record ClientLeft(int clientNum) implements Event {
}

// die Warteschlange der Ereignisse, von zwei virtuellen Threads gespeist: der Tastatur und dem Lesen des Clients
final BlockingQueue<Event> events = new LinkedBlockingQueue<>();

void main(String[] args) throws InterruptedException {
    int port = args.length == 1 ? integer(args[0]) : -1;
    if (port < 1 || port > 65535) {
        IO.println(SYNTAX);
        return;
    }
    // der lauschende Dienst
    try (var listener = new ServerSocket(port)) {
        IO.println("Generic server started on " + listener.getLocalSocketAddress());
        // ein virtueller Thread liest die Tastatur während der gesamten Dauer des Programms
        Thread.ofVirtual().start(this::readKeyboard);
        // Dienstschleife - der Server wird durch Ctrl-C gestoppt
        for (int clientNum = 0; ; clientNum++) {
            // Warten auf einen Client
            IO.println("Waiting for the next client...");
            Socket client = listener.accept();
            IO.println("Client " + client.getRemoteSocketAddress());
            // ein virtueller Thread zeigt die vom Client gesendeten Zeilen an
            int number = clientNum;
            Thread reception = Thread.ofVirtual().start(() -> receive(client, number));
            IO.println("Type your responses (bye to close the connection with the client):");
            boolean carryOn = true;
            // die Verbindung zum Client wird beim Verlassen des try geschlossen
            try (client; var writer = new OutputStreamWriter(client.getOutputStream(), UTF_8)) {
                // die Ereignisse werden bis zum Ende der Verbindung mit diesem Client verarbeitet
                carryOn = serve(writer, clientNum);
            } catch (IOException e) {
                IO.println("The following error occurred while writing: " + e.getMessage());
            }
            // wir warten auf das Ende des Empfangs-Threads
            reception.join();
            // Ende der Standardeingabe: der Server stoppt
            if (!carryOn) {
                return;
            }
        }
    } catch (IOException e) {
        IO.println("The following error occurred on the server: " + e.getMessage());
    }
}

// der Dialog mit Client Nr. [clientNum]; liefert false, wenn die Standardeingabe geschlossen wurde
boolean serve(Writer writer, int clientNum) throws IOException, InterruptedException {
    while (true) {
        // wir warten entweder auf eine über die Tastatur eingegebene Zeile oder auf das Weggehen des Clients
        switch (events.take()) {
            case ClientLeft(int number) when number == clientNum -> {
                IO.println("[the client closed the connection]");
                return true;
            }
            case ClientLeft _ -> {
                // Weggang eines früheren Clients, bereits verarbeitet: er wird ignoriert
            }
            case EndOfInput _ -> {
                return false;
            }
            case Input(String response) when response.strip().equalsIgnoreCase("bye") -> {
                IO.println("[connection closed by the server]");
                return true;
            }
            case Input(String response) -> {
                // die Antwort wird an den Client gesendet
                writer.write(response + "\r\n");
                writer.flush();
            }
        }
    }
}

// liest die Tastatur und legt jede eingegebene Zeile in die Warteschlange der Ereignisse
void readKeyboard() {
    String line;
    while ((line = IO.readln()) != null) {
        events.add(new Input(line));
    }
    events.add(new EndOfInput());
}

// zeigt die vom Client gesendeten Zeilen an, bis die Verbindung geschlossen wird
void receive(Socket client, int clientNum) {
    try {
        var reader = new BufferedReader(new InputStreamReader(client.getInputStream(), UTF_8));
        String request;
        while ((request = reader.readLine()) != null) {
            IO.println("<-- " + request);
        }
    } catch (IOException e) {
        // die Verbindung wurde während des Lesens vom Server geschlossen
    }
    // der Weggang des Clients wird dem Hauptprogramm gemeldet
    events.add(new ClientLeft(clientNum));
}

// eine ganze Zahl oder -1, wenn die Zeichenkette keine ist
int integer(String string) {
    try {
        return Integer.parseInt(string);
    } catch (NumberFormatException e) {
        return -1;
    }
}
  • Zeilen 12–25: die drei Arten von Ereignissen, Records, die ein versiegeltes Interface ([sealed], Java 17) implementieren: Die Klausel [permits] liefert eine vollständige Liste seiner Implementierungen. In einer kompakten Quelldatei sind diese Typen Member der impliziten Klasse;
  • Zeile 28: die Ereigniswarteschlange. [LinkedBlockingQueue] kann ohne besondere Vorkehrungen nebenläufig von mehreren Threads verwendet werden;
  • Zeile 37: der lauschende Service, auf allen Netzwerkschnittstellen des Rechners;
  • Zeile 40: der virtuelle Tastatur-Lese-Thread, der die Methode [readKeyboard] (Zeilen 100–106) ausführt. Er stellt jede gelesene Zeile in die Warteschlange und löst dann ein [EndOfInput]-Ereignis aus, wenn die Standardeingabe geschlossen wird. Er wird nur einmal gestartet: Wenn ein Client die Verbindung schließt, wird der laufende Tastaturlesevorgang vom nächsten Client weiterverwendet. Das Starten eines neuen Lesevorgangs für jeden Client würde dazu führen, dass zwei Lesevorgänge um dieselben Tastenanschläge konkurrieren;
  • Zeile 42: Endlosschleife, die auf Clients wartet. Der Benutzer beendet den Server mit Strg+C;
  • Zeile 45: Warten auf einen Client. Sobald der Client eintrifft, stellt der [Socket] , den [accept] zurückgibt, die Serverseite der offenen Verbindung mit dem Client dar;
  • Zeile 49: Das Lesen der vom Client gesendeten Zeilen übernimmt ein virtueller Thread, der die Methode [receive] (Zeilen 109–121) ausführt. Wenn die Verbindung geschlossen wird, stellt dieser Thread ein [ClientLeft]-Ereignis mit der Nummer des Clients in die Warteschlange;
  • Zeilen 53–58: Die Kommunikation mit dem Client übernimmt die Methode [serve]. Die Verbindung wird beim Verlassen der [try]-mit-Ressourcen-Anweisung geschlossen;
  • Zeile 60: Das Programm wartet mit [join] darauf, dass der Empfangs-Thread beendet wird;
  • Zeilen 62–64: Wurde die Standardeingabe geschlossen, wird der Server heruntergefahren;
  • Zeilen 72–97: Die Methode [serve] entnimmt der Warteschlange Ereignisse (Zeile 75) und verarbeitet sie mit einem [switch] über Record-Muster (Java 21). Da das Interface versiegelt ist, prüft der Compiler, ob alle Fälle behandelt werden:
    • Zeile 76: Das Muster [ClientLeft(int number)] zerlegt den Record und speichert dessen Feld in der Variablen [number]; der Guard [when] prüft, ob es sich um den aktuellen Client handelt;
    • Zeile 80: Ein [ClientLeft]-Ereignis für einen anderen Client stammt von einer Verbindung, die der Server selbst geschlossen hat (Befehl [bye]): Es wird ignoriert. Das anonyme Muster [_] (Java 22) zeigt an, dass das Objekt nicht benötigt wird;
    • Zeilen 83–85: Ende der Standardeingabe;
    • Zeilen 86–89: Der Befehl [bye] schließt die Verbindung zum aktuellen Client;
    • Zeilen 90–94: Jede andere eingegebene Zeile wird, abgeschlossen mit \r\n, an den Client gesendet.

Verwenden wir diesen Server, um einen Webserver zu simulieren, der von einem Client namens HTTP abgefragt wird – in diesem Fall [curl]. Der generische Server läuft auf Port 27101. In einem anderen Fenster fragen wir mit [curl] die URL [http://localhost:27101/example.html] ab. [curl] verbindet sich dann mit Port 27101 des Rechners [localhost] und fordert das Dokument [/example.html] an. Hier das Serverfenster:

> java Internet07.java 27101
Generic server started on 0.0.0.0/0.0.0.0:27101
Waiting for the next client...
Client /127.0.0.1:60386
Type your responses (bye to close the connection with the client):
<-- GET /example.html HTTP/1.1
<-- Host: localhost:27101
<-- User-Agent: curl/8.5.0
<-- Accept: */*
<-- 
HTTP/1.1 200 OK
Server: generic tcp server
Connection: close
Content-Type: text/html; charset=utf-8

<html><head><title>Generic server</title></head>
<body><h1>Response of the generic server</h1></body></html>
bye
[connection closed by the server]
Waiting for the next client...
  • Zeile 4: Ein Client ist eingetroffen;
  • Zeilen 6–10: Wir sehen die von [curl] gesendete HTTP-Anfrage, die mit einer Leerzeile endet. Ein Browser würde deutlich mehr Header senden (unterstützte Sprachen und Formate, Komprimierung, Cookies usw.): Der Leser kann das testen, indem er dieselbe URL in seinem Browser aufruft;
  • Zeilen 11–17: Der Benutzer an der Tastatur ist hier der eigentliche Server und formuliert die Antwort von Hand. Er beschränkt sich auf das absolute Minimum: eine Statuszeile, drei Header, eine Leerzeile und das HTML-Dokument. Er gibt die Größe des Dokuments ([Content-Length]) nicht an, kündigt aber an, dass er die Verbindung nach dem Senden schließen wird ([Connection: close]). Das genügt: Wenn der Client sieht, dass die Verbindung geschlossen wird, weiß er, dass die Antwort vollständig ist;
  • Zeilen 18–19: Der Benutzer hat [bye] eingegeben: Der Server schließt die Verbindung zum Client;
  • Zeile 20: Der Server wartet auf einen neuen Client. Wir beenden ihn mit Strg+C.

Und das hat [curl] angezeigt:

> curl -sv http://localhost:27101/example.html
* Host localhost:27101 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
*   Trying 127.0.0.1:27101...
* Connected to localhost (127.0.0.1) port 27101
> GET /example.html HTTP/1.1
> Host: localhost:27101
> User-Agent: curl/8.5.0
> Accept: */*
> 
< HTTP/1.1 200 OK
< Server: generic tcp server
< Connection: close
< Content-Type: text/html; charset=utf-8
< 
{ [50 bytes data]
* Closing connection
<html><head><title>Generic server</title></head>
<body><h1>Response of the generic server</h1></body></html>

[curl] hat genau das empfangen, was im Serverfenster eingegeben wurde (Zeilen 12–16 und 19–20), und hat erkannt, dass die Verbindung geschlossen wurde (Zeile 18). Ein Browser hätte die empfangene HTML-Seite angezeigt, mit dem Titel [Generic server] im Tab.

12.6.5. Ein Webclient

Im vorherigen Beispiel haben wir die HTTP-Header gesehen, die von [curl] gesendet werden. Wir schreiben nun einen Webclient, der eine URL als Parameter entgegennimmt und alles, was der Server ihm sendet, auf dem Bildschirm anzeigt. Wir gehen davon aus, dass der Server das Protokoll HTTP/1.1 unterstützt. Unser Client sendet die folgende Anfrage:

1
2
3
4
GET /document HTTP/1.1
Host: machine:port
User-Agent: web-client-java-course
Connection: close
  • Die erste Zeile gibt das gewünschte Dokument an;
  • der Header [Host] gibt den abgefragten Server an;
  • der Header [User-Agent] identifiziert unseren Client;
  • der Header [Connection] zeigt an, dass der Server die Verbindung schließen soll, nachdem er uns geantwortet hat: Wir lesen seine Antwort bis zum Ende des Stroms;
  • Die leere Zeile beendet die Anfrage.

Wenn wir in der ersten Zeile [GET] durch [HEAD] ersetzen, sendet uns der Server nur die HTTP-Header seiner Antwort und nicht das Dokument.

Unser Webclient wird wie folgt aufgerufen: [java Internet08.java URL command], wobei [URL] die gewünschte URL ist und [command] eines der beiden Schlüsselwörter [GET] oder [HEAD]. Das Programm [Internet08.java] lautet wie folgt:

import static java.nio.charset.StandardCharsets.UTF_8;

// Web-Client: fordert eine URL mit einer "von Hand" geschriebenen HTTP/1.1-Anfrage an
// und zeigt alles an, was der Server zurücksendet (HTTP-Header und Dokument)
// Aufruf: java Internet08.java URL GET|HEAD

final String SYNTAX = "Syntax: java Internet08.java http://machine[:port][/document] GET|HEAD";

void main(String[] args) {
    if (args.length != 2) {
        IO.println(SYNTAX);
        return;
    }
    // Prüfung der URL: sie muss absolut sein und das Schema http verwenden
    URI uri = parse(args[0]);
    if (uri == null) {
        IO.println("Incorrect URL [" + args[0] + "]. " + SYNTAX);
        return;
    }
    // Prüfung des Befehls
    String command = args[1].toUpperCase();
    if (!command.equals("GET") && !command.equals("HEAD")) {
        IO.println("The second parameter must be GET or HEAD. " + SYNTAX);
        return;
    }

    // Verbindung zum Webserver: Port 80 ist der Standardport von HTTP
    int port = uri.getPort() == -1 ? 80 : uri.getPort();
    try (var client = new Socket(uri.getHost(), port);
         var reader = new BufferedReader(new InputStreamReader(client.getInputStream(), UTF_8));
         var writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream(), UTF_8))) {
        // die Anfrage: Befehlszeile, HTTP-Header, Leerzeile; HTTP verlangt das Zeilenende \r\n
        writer.write(command + " " + pathAndQuery(uri) + " HTTP/1.1\r\n");
        writer.write("Host: " + uri.getRawAuthority() + "\r\n");
        writer.write("User-Agent: web-client-java-course\r\n");
        writer.write("Connection: close\r\n");
        writer.write("\r\n");
        // die Anfrage wird in einem Zug über das Netzwerk gesendet
        writer.flush();
        // die Antwort wird gelesen, bis der Server die Verbindung schließt
        String line;
        while ((line = reader.readLine()) != null) {
            IO.println(line);
        }
    } catch (IOException e) {
        IO.println("The following error occurred: " + e.getClass().getSimpleName()
                + " (" + e.getMessage() + ")");
    }
}

// eine korrekte absolute http-URL oder null
URI parse(String url) {
    try {
        URI uri = new URI(url);
        return uri.isAbsolute() && uri.getScheme().equals("http") && uri.getHost() != null ? uri : null;
    } catch (URISyntaxException e) {
        return null;
    }
}

// der Pfad des Dokuments und die möglichen Parameter, zum Beispiel /hello?name=Serge
String pathAndQuery(URI uri) {
    String path = uri.getRawPath().isEmpty() ? "/" : uri.getRawPath();
    return uri.getRawQuery() == null ? path : path + "?" + uri.getRawQuery();
}

Neu in diesem Programm ist die Verwendung der Klasse [URI] (Paket [java.net]). Das Programm erhält eine URL (Uniform Resource Locator), eine spezielle Form der URI (Uniform Resource Identifier), in der Form [http://server:port/path?param1=val1&param2=val2]. Die Klasse [URI] dient dazu, diese Zeichenkette in ihre einzelnen Bestandteile zu zerlegen:

  • Zeilen 52–59: Der Konstruktor [URI(String)] analysiert die Zeichenkette und löst eine [URISyntaxException] (eine geprüfte Ausnahme) aus, wenn es sich nicht um eine gültige URI handelt; die statische Methode [URI.create] tut dasselbe, indem sie eine [IllegalArgumentException] auslöst. Anschließend prüfen wir, ob die URI absolut ist (sie beginnt mit einem Schema), ob das Schema [http] ist (unser Client kann die TLS-Aushandlung von [https] nicht durchführen) und ob sie auf einen Rechner verweist. Sobald das [URI]-Objekt konstruiert ist, haben wir Zugriff auf die verschiedenen Elemente der URI. Wurde das Objekt [uri] also aus der Zeichenkette [http://localhost:27110/hello?name=Serge] konstruiert, erhalten wir:
    • [uri.getScheme()]: http;
    • [uri.getHost()]: localhost;
    • [uri.getPort()]: 27110 (-1, wenn der Port in der URL nicht angegeben ist; in diesem Fall ist es der Standardport des Schemas – 80 für HTTP, 443 für HTTPS);
    • [uri.getRawAuthority()]: localhost:27110;
    • [uri.getRawPath()]: /hello;
    • [uri.getRawQuery()]: name=Serge;
    • Die Methoden [getPath], [getQuery] … liefern dieselben Elemente, jedoch decodiert (was die Kodierung einer URL ist, sehen wir später). Zum Aufbau einer Anfrage müssen die „Raw“-Versionen ([getRawXxx]) verwendet werden;
  • Zeilen 62–65: der Pfad und die Parameter, so wie sie in der Anfrage erscheinen müssen; ein leerer Pfad bezeichnet das Stammverzeichnis der Site ([/]);
  • Zeile 21: Der Befehl muss [GET] oder [HEAD] sein;
  • Zeilen 28–29: Verbindung zu dem durch die URL bezeichneten Server, auf Port 80, wenn die URL keinen angibt;
  • Zeile 31: Der Schreibstrom ist ein [BufferedWriter] ohne automatisches Leeren des Puffers;
  • Zeilen 33–37: die HTTP-Anfrage. HTTP verlangt Zeilenenden mit \r\n, die explizit geschrieben werden müssen;
  • Zeile 39: Die Anfrage wird in einem Zug gesendet, nachdem sie vollständig geschrieben wurde;
  • Zeilen 41–44: Die Antwort wird angezeigt, bis der Server die Verbindung schließt.

Fordern wir nur die Header des Stammverzeichnisses unseres Testservers an:

1
2
3
4
5
> java Internet08.java http://localhost:27110/ HEAD
HTTP/1.1 200 OK
Date: Sat, 03 Oct 2026 17:40:36 GMT
Content-type: text/html; charset=utf-8
Content-length: 171

Wir erhalten die Statuszeile und die Header, gefolgt von einer Leerzeile, aber nicht das Dokument. Der Header [Content-length] gibt die Größe an, die das Dokument mit dem Befehl [GET] gehabt hätte. Mit dem Befehl [GET] und einem in Chunks gesendeten Dokument:

1
2
3
4
5
6
7
8
9
> java Internet08.java "http://localhost:27110/hello?name=Serge" GET
HTTP/1.1 200 OK
Date: Sat, 03 Oct 2026 17:40:36 GMT
Transfer-encoding: chunked
Content-type: text/plain; charset=utf-8

c
Hello Serge!
0

Beachten Sie die Anführungszeichen um die URL im Befehl: Ohne sie würden einige Befehlsinterpreter dem Zeichen [?] eine besondere Bedeutung zuweisen. Das Dokument ([Hello Serge!]) ist, wie bereits gesehen, von den Größenangaben seiner Chunks eingerahmt. Unser Client zeigt die rohe Antwort an; ein echter HTTP-Client muss dagegen das Dokument aus den Chunks wieder zusammensetzen.

Ein nicht vorhandenes Dokument:

1
2
3
4
> java Internet08.java http://localhost:27110/unknown GET
HTTP/1.1 404 Not Found
Date: Sat, 03 Oct 2026 17:40:36 GMT
Content-length: 0

Eine URL, für die eine Umleitung erfolgt:

1
2
3
4
5
> java Internet08.java http://localhost:27110/old GET
HTTP/1.1 302 Temporary Redirect
Date: Sat, 03 Oct 2026 17:40:36 GMT
Content-length: 0
Location: /hello?name=visitor
  • Zeile 2: Der Code 302 zeigt eine Umleitung an: Das angeforderte Dokument befindet sich vorübergehend unter einer anderen Adresse. Die auf den Code folgende Meldung ist beliebig: Der JDK-Server schreibt [Temporary Redirect], während andere Server [Found] (die Meldung aus dem RFC) oder [Moved Temporarily] schreiben könnten;
  • Zeile 5: Diese Adresse wird vom Header [Location] geliefert. Sie ist hier relativ: Die vollständige Adresse lautet [http://localhost:27110/hello?name=visitor].

Unser Client hat dort aufgehört. Ein Browser hätte dagegen automatisch die neue Adresse angefordert. Genau das wird unser nächster Client tun.

Schließlich wird eine [https]-URL abgelehnt:

> java Internet08.java https://www.oracle.com/java/ GET
Incorrect URL [https://www.oracle.com/java/]. Syntax: java Internet08.java http://machine[:port][/document] GET|HEAD

12.6.6. Ein Webclient, der Umleitungen verarbeitet

Der vorherige Webclient verarbeitet eine mögliche Umleitung der von ihm angeforderten URL nicht. Die Statuscodes für Umleitungen lauten wie folgt:

Code
Bedeutung
301 Moved Permanently
Das Dokument ist dauerhaft unter eine neue Adresse umgezogen; ein Browser kann die neue Adresse speichern
302 Found
Das Dokument befindet sich vorübergehend unter einer anderen Adresse
303 See Other
Die Antwort muss mit der Methode [GET] unter einer anderen Adresse angefordert werden (wird nach dem Absenden eines Formulars verwendet)
307 Temporary Redirect, 308 Permanent Redirect
Wie 302 und 301, aber der Client muss die Anfrage mit derselben Methode erneut senden ([POST] bleibt [POST])

In allen Fällen wird die neue Adresse vom Header [Location] geliefert, in absoluter oder relativer Form. Eine Umleitung anhand des Vorkommens eines Wortes wie [moved] in der Statuszeile zu erkennen, wäre unzuverlässig: Die auf den Code folgende Meldung ist beliebig, und wir haben gerade gesehen, dass der JDK-Server mit [302 Temporary Redirect] antwortet. Wir stützen uns auf den Statuscode selbst.

Das Programm [Internet09.java] lautet wie folgt:

import static java.nio.charset.StandardCharsets.UTF_8;

// Web-Client, der den Weiterleitungen folgt (Codes 301, 302, 303, 307, 308)
// Aufruf: java Internet09.java URL GET|HEAD

final String SYNTAX = "Syntax: java Internet09.java http://machine[:port][/document] GET|HEAD";
// die HTTP-Statuscodes, die eine Weiterleitung signalisieren
final Set<Integer> REDIRECTION_CODES = Set.of(301, 302, 303, 307, 308);
// maximale Anzahl der verfolgten Weiterleitungen
final int MAX_REDIRECTIONS = 3;

void main(String[] args) {
    if (args.length != 2) {
        IO.println(SYNTAX);
        return;
    }
    URI uri = parse(args[0]);
    if (uri == null) {
        IO.println("Incorrect URL [" + args[0] + "]. " + SYNTAX);
        return;
    }
    String command = args[1].toUpperCase();
    if (!command.equals("GET") && !command.equals("HEAD")) {
        IO.println("The second parameter must be GET or HEAD. " + SYNTAX);
        return;
    }

    try {
        // eine Iteration pro angeforderter URL
        for (int nbRedirections = 0; ; nbRedirections++) {
            // die URL wird angefordert und die mögliche Weiterleitungsadresse abgerufen
            Optional<String> location = request(uri, command);
            // keine Weiterleitung: wir sind fertig
            if (location.isEmpty()) {
                break;
            }
            // zu viele Weiterleitungen: wir geben auf
            if (nbRedirections == MAX_REDIRECTIONS) {
                IO.println("<-- Giving up: more than " + MAX_REDIRECTIONS + " redirections -->");
                break;
            }
            // die neue URL: die Weiterleitungsadresse kann absolut oder relativ zur aktuellen URL sein
            uri = uri.resolve(location.get());
            IO.println("<-- Redirection to " + uri + " -->\n");
        }
    } catch (IOException | IllegalArgumentException e) {
        IO.println("The following error occurred: " + e.getClass().getSimpleName()
                + " (" + e.getMessage() + ")");
    }
}

// fordert die URL [uri] an, zeigt die Antwort des Servers an
// liefert die Weiterleitungsadresse oder ein leeres Optional, wenn es keine Weiterleitung gibt
Optional<String> request(URI uri, String command) throws IOException {
    int port = uri.getPort() == -1 ? 80 : uri.getPort();
    try (var client = new Socket(uri.getHost(), port);
         var reader = new BufferedReader(new InputStreamReader(client.getInputStream(), UTF_8));
         var writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream(), UTF_8))) {
        // die HTTP-Anfrage
        writer.write(command + " " + pathAndQuery(uri) + " HTTP/1.1\r\n");
        writer.write("Host: " + uri.getRawAuthority() + "\r\n");
        writer.write("User-Agent: web-client-java-course\r\n");
        writer.write("Connection: close\r\n");
        writer.write("\r\n");
        writer.flush();

        // die Statuszeile, zum Beispiel: HTTP/1.1 302 Found
        String statusLine = Objects.requireNonNullElse(reader.readLine(), "");
        IO.println(statusLine);
        String[] fields = statusLine.split(" ");
        boolean redirection = fields.length >= 2 && REDIRECTION_CODES.contains(integer(fields[1]));

        // die HTTP-Header, bis zur Leerzeile
        String location = null;
        String header;
        while ((header = reader.readLine()) != null && !header.isEmpty()) {
            IO.println(header);
            // der Name eines HTTP-Headers ist nicht von der Groß-/Kleinschreibung abhängig
            if (redirection && header.regionMatches(true, 0, "Location:", 0, "Location:".length())) {
                location = header.substring("Location:".length()).strip();
            }
        }
        IO.println();
        // das mögliche Dokument
        String line;
        while ((line = reader.readLine()) != null) {
            IO.println(line);
        }
        return Optional.ofNullable(location);
    }
}

// eine korrekte absolute http-URL oder null
URI parse(String url) {
    try {
        URI uri = new URI(url);
        return uri.isAbsolute() && uri.getScheme().equals("http") && uri.getHost() != null ? uri : null;
    } catch (URISyntaxException e) {
        return null;
    }
}

// der Pfad des Dokuments und die möglichen Parameter, zum Beispiel /hello?name=Serge
String pathAndQuery(URI uri) {
    String path = uri.getRawPath().isEmpty() ? "/" : uri.getRawPath();
    return uri.getRawQuery() == null ? path : path + "?" + uri.getRawQuery();
}

// eine ganze Zahl oder -1, wenn die Zeichenkette keine ist
int integer(String string) {
    try {
        return Integer.parseInt(string);
    } catch (NumberFormatException e) {
        return -1;
    }
}

Gegenüber der vorherigen Version ergeben sich folgende Änderungen:

  • Zeile 8: die Statuscodes, die eine Umleitung anzeigen, in einer festen Menge, die mit [Set.of] erzeugt wird (Kapitel 5);
  • Zeile 10: die maximal zulässige Anzahl von Umleitungen. Ohne Begrenzung könnte ein falsch konfigurierter Server unseren Client in einer Endlosschleife gefangen halten (Browser geben nach etwa zwanzig Umleitungen auf);
  • Zeile 30: Der Code, der zuvor für eine einzelne URL ausgeführt wurde, kann nun nacheinander für mehrere URL-Einträge ausgeführt werden;
  • Zeile 32: Die Methode [request] fordert die aktuelle URL an, zeigt die Antwort an und gibt die Umleitungsadresse in Form eines [Optional<String>] (Kapitel 3) zurück, das leer ist, wenn keine Umleitung erfolgt;
  • Zeilen 38–41: Der Vorgang wird abgebrochen, wenn die maximale Anzahl von Umleitungen erreicht ist;
  • Zeile 43: Die Methode [resolve] der Klasse [URI] berechnet die neue URL. Ist [location] eine absolute Adresse, wird sie unverändert verwendet; ist sie relativ, wird sie anhand der aktuellen URL [uri] vervollständigt. [resolve] löst eine [IllegalArgumentException] aus, wenn die Adresse fehlerhaft ist: Sie wird in Zeile 46 abgefangen;
  • Zeilen 54–91: die Anfrage für eine URL:
    • Zeile 68: Die Statuszeile wird gelesen, zum Beispiel [HTTP/1.1 302 Temporary Redirect]. [Objects.requireNonNullElse] ersetzt [null] (Verbindung vom Server vor jeder Antwort geschlossen) durch eine leere Zeichenkette;
    • Zeilen 70–71: Der Code (das zweite Feld der Zeile) wird extrahiert und geprüft, ob es sich um einen der Umleitungscodes handelt;
    • Zeilen 76–82: Die Header werden bis zur leeren Zeile gelesen. Bei einer Umleitung wird nach dem Header [Location] gesucht, wobei die Groß- und Kleinschreibung ignoriert wird, da die Header-Namen in HTTP nicht zwischen Groß- und Kleinschreibung unterscheiden: [regionMatches(true, ...)] vergleicht den Anfang des Headers mit [Location:], ohne die Groß- und Kleinschreibung zu beachten;
    • Zeilen 85–89: Der Rest der Antwort wird angezeigt, gefolgt von der gefundenen Umleitungsadresse.

Sehen wir uns noch einmal die URL [/old] an:

> java Internet09.java http://localhost:27110/old GET
HTTP/1.1 302 Temporary Redirect
Date: Sat, 03 Oct 2026 17:40:36 GMT
Content-length: 0
Location: /hello?name=visitor

<-- Redirection to http://localhost:27110/hello?name=visitor -->

HTTP/1.1 200 OK
Date: Sat, 03 Oct 2026 17:40:36 GMT
Transfer-encoding: chunked
Content-type: text/plain; charset=utf-8

e
Hello visitor!
0
  • Zeilen 2–6: die vorübergehende Umleitung auf eine relative Adresse;
  • Zeile 7: die neue URL, ergänzt durch [uri.resolve(location)];
  • Zeilen 9–17: die Antwort auf die neue URL. Das Dokument, das 0xe = 14 Bytes lang ist, wurde in Chunks gesendet.

Die URL [/moved] wird dauerhaft auf eine absolute Adresse umgeleitet:

> java Internet09.java http://localhost:27110/moved GET
HTTP/1.1 301 Moved Permanently
Date: Sat, 03 Oct 2026 17:40:36 GMT
Content-length: 0
Location: http://localhost:27110/

<-- Redirection to http://localhost:27110/ -->

HTTP/1.1 200 OK
Date: Sat, 03 Oct 2026 17:40:36 GMT
Content-type: text/html; charset=utf-8
Content-length: 171

<!DOCTYPE html>
<html lang="en">
<head><meta charset="utf-8"><title>Test server</title></head>
<body><h1>Welcome to the test server of the Java course</h1></body>
</html>

Die URL [/loop] leitet auf sich selbst um:

> java Internet09.java http://localhost:27110/loop HEAD
HTTP/1.1 302 Temporary Redirect
Date: Sat, 03 Oct 2026 17:40:37 GMT
Location: /loop

<-- Redirection to http://localhost:27110/loop -->

HTTP/1.1 302 Temporary Redirect
Date: Sat, 03 Oct 2026 17:40:37 GMT
Location: /loop

<-- Redirection to http://localhost:27110/loop -->

HTTP/1.1 302 Temporary Redirect
Date: Sat, 03 Oct 2026 17:40:37 GMT
Location: /loop

<-- Redirection to http://localhost:27110/loop -->

HTTP/1.1 302 Temporary Redirect
Date: Sat, 03 Oct 2026 17:40:37 GMT
Location: /loop

<-- Giving up: more than 3 redirections -->

Unser Client ist drei Umleitungen gefolgt und hat dann aufgegeben (Zeile 24). Mit dem Befehl [HEAD] wurde kein Dokument gesendet.

Das Protokoll des Webservers hat alle Anfragen zu den Einträgen [A web client] and [A web client that handles redirects] aufgezeichnet:

> java Internet03.java
Web server started on http://localhost:27110
HEAD / HTTP/1.1 -> 200
GET /hello?name=Serge HTTP/1.1 -> 200
GET /unknown HTTP/1.1 -> 404
GET /old HTTP/1.1 -> 302
GET /old HTTP/1.1 -> 302
GET /hello?name=visitor HTTP/1.1 -> 200
GET /moved HTTP/1.1 -> 301
GET / HTTP/1.1 -> 200
HEAD /loop HTTP/1.1 -> 302
HEAD /loop HTTP/1.1 -> 302
HEAD /loop HTTP/1.1 -> 302
HEAD /loop HTTP/1.1 -> 302

Für jede Umleitung zeigt es die Anfrage, die sie ausgelöst hat, gefolgt von der Anfrage an die neue Adresse (Zeilen 7–8 und 9–10) sowie die vier Anfragen der unterbrochenen Schleife (Zeilen 11–14).

Einen HTTP-Client über TCP zu schreiben, hilft, das Protokoll zu verstehen, aber ein echter Client muss viele weitere Dinge bewältigen: TLS-Verschlüsselung, Chunked Transfer, Komprimierung, persistente Verbindungen, HTTP/2 … Der zweite Teil dieses Kapitels stellt die Java-Klasse [HttpClient] vor, die uns all dies abnimmt.

12.7. Auf ein Protokoll spezialisierte Java-Klassen

In den vorherigen Beispielen wurde das HTTP-Protokoll mit einem TCP-Client abgewickelt: Wir mussten die Anfragen selbst aufbauen, die Statuszeilen und Header analysieren und Umleitungen verfolgen. Auf dieselbe Weise hätten wir einen SMTP- oder POP-Client bauen können. Für diese Protokolle gibt es spezialisierte Klassen: Sie verstehen das Kommunikationsprotokoll zwischen Client und Server und ersparen dem Entwickler dessen Verwaltung. Für HTTP stellt das JDK die Klasse [HttpClient] bereit; für E-Mail wird die Bibliothek Jakarta Mail verwendet. Wir stellen sie nun vor.

Die Programme dieses zweiten Teils sind, wie die des ersten, kompakte Quelldateien im Ordner [12-internet], fortlaufend nummeriert ([Internet10] bis [Internet19]). Diejenigen, die eine Bibliothek benötigen (Jackson für JSON, Jakarta Mail für E-Mail), sind Maven-Projekte, die in einem gleichnamigen Ordner organisiert sind ([Internet10/], [Internet14/], [Internet19/]). Die Beispielanwendung am Ende des Kapitels ist ein eigenständiges Maven-Projekt, [TaxV8]. Die verwendeten Ports haben die Form 272xx.

12.7.1. Die inzwischen veralteten Klassen URL und HttpURLConnection

Vor Java 11 standen einem Java-Programm, das HTTP verwenden wollte, zwei Klassen zur Verfügung, die seit den ersten Java-Versionen vorhanden sind:

  • die Klasse [URL], deren Methode [openStream] mit einer einzigen Anweisung einen Lesestrom für das durch die URL bezeichnete Dokument lieferte;
  • die Klasse [HttpURLConnection], die über die Methode [openConnection] von [URL] bezogen wurde und flexibler war: Sie erlaubte es, die HTTP-Methode ([GET], [HEAD], [POST]) zu wählen, Header hinzuzufügen sowie den Statuscode und die Antwort-Header zu lesen.

Diese Klassen existieren in Java 25 weiterhin, sind aber nicht gut gealtert: [HttpURLConnection] ist vollständig synchron, unterstützt nur HTTP/1.1, wird über eine Abfolge von Aufrufen in fester Reihenfolge verwendet (Header setzen, bevor das Dokument geschrieben wird, Statuscode lesen, bevor das Dokument gelesen wird …) und meldet Fehlercodes über Ausnahmen. Die Konstruktoren der Klasse [URL], die nicht alle URLs korrekt analysierten, sind seit Java 20 als veraltet markiert: Sie erzeugen nun ein [URI]-Objekt und konvertieren es bei Bedarf mit dessen Methode [toURL]. Ein kleines Programm [Old.java], das die Anweisung [var url = new URL("http://localhost:27210/");] enthält, erzeugt die folgende Compiler-Warnung:

1
2
3
4
5
> javac -Xlint:all Old.java
Old.java:2: warning: [deprecation] URL(String) in URL has been deprecated
    var url = new URL("http://localhost:27210/");
              ^
1 warning

Java 11 führte die Klasse [HttpClient] (im Paket [java.net.http]) ein, die von Grund auf für HTTP/1.1 und HTTP/2 konzipiert wurde, für synchrone wie asynchrone Anfragen, und die ihre Verbindungen wiederverwenden und von mehreren Threads gleichzeitig genutzt werden kann. Sie sollten heute diese Klasse verwenden. Auf [URL] und [HttpURLConnection] gehen wir nicht weiter ein, auch wenn der Leser ihnen in Legacy-Code weiterhin begegnen wird.

12.7.2. Die Klasse HttpClient

12.7.2.1. Ein Test-Webserver

Um die Möglichkeiten von [HttpClient] zu veranschaulichen, benötigen wir einen Webserver mit mehr Funktionen als der aus Teil 1 ([Internet03.java]): Er muss Formulare annehmen, JSON austauschen und Verzögerungen verarbeiten können. Wir schreiben also einen zweiten Testserver, [Internet10], der ebenfalls auf dem HTTP-Server des JDK basiert. Für den JSON-Austausch verwendet er die Bibliothek Jackson (Kapitel 5): Es handelt sich daher um ein Maven-Projekt. Auch hier ist es nicht nötig, dieses Programm im Detail zu verstehen; Sie müssen nur wissen, womit jede URL antwortet. Das Projekt hat die übliche Maven-Verzeichnisstruktur:

1
2
3
4
5
12-internet/Internet10/
  pom.xml
  src/main/java/internet/
    Internet10.java      the server
    Person.java          a person, exchanged in JSON format

Die Datei [pom.xml] lautet wie folgt:

<?xml version="1.0" encoding="UTF-8"?>
<!-- ein lokaler Test-Webserver für die Clients auf Basis von java.net.http.HttpClient -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>examples.internet</groupId>
    <artifactId>internet10</artifactId>
    <version>1.0</version>

    <properties>
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- Jackson 3 für den Austausch im JSON-Format -->
        <dependency>
            <groupId>tools.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>3.1.5</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.15.0</version>
                <configuration>
                    <parameters>true</parameters>
                    <compilerArgs>
                        <arg>-Xlint:all</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
            <!-- mvn exec:java führt die Hauptklasse aus -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <mainClass>internet.Internet10</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
  • Zeilen 8–10: die Projektkennung;
  • Zeilen 12–15: die Java-Version und die Kodierung der Quelldateien;
  • Zeilen 19–23: die einzige Abhängigkeit, Jackson 3;
  • Zeilen 28–38: der Compiler, mit allen Warnungen ([-Xlint:all]);
  • Zeilen 40–47: das Plugin, das die Hauptklasse mit dem Befehl [mvn exec:java] ausführt.

Der Typ [Person] ist ein Record:

1
2
3
4
5
package internet;

// eine Person, im JSON-Format ausgetauscht
public record Person(int id, String name, int age) {
}

Die Klasse [Internet10] lautet wie folgt:

package internet;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.LinkedHashMap;
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;
import java.util.stream.Collectors;
import tools.jackson.databind.json.JsonMapper;

// ein lokaler Webserver, der das Ziel der Clients auf Basis von java.net.http.HttpClient sein wird
// Aufruf: mvn exec:java [-Dexec.args="port"]   (standardmäßig Port 27210); Stopp mit Ctrl-C
public class Internet10 {

    // die Startseite: ein HTML-Dokument
    private static final String HOME = """
            <!DOCTYPE html>
            <html lang="en">
            <head><meta charset="utf-8"><title>Test server</title></head>
            <body><h1>Welcome to the HttpClient test server</h1></body>
            </html>
            """;
    // die Typen der gesendeten Dokumente
    private static final String TEXT = "text/plain; charset=utf-8";
    private static final String JSON = "application/json";
    // GET /api/persons/n: eine durch ihre Nummer bezeichnete Person
    private static final Pattern PERSON = Pattern.compile("GET /api/persons/(\\d+)");

    // eine kleine "Datenbank" von Personen, im JSON-Format ausgetauscht, und ihr Lock
    private final List<Person> persons = new ArrayList<>(List.of(
            new Person(1, "Dupont", 42), new Person(2, "Durand", 35)));
    private final Object lock = new Object();
    // der Konverter Objekte <-> JSON
    private final JsonMapper mapper = JsonMapper.builder().build();

    public static void main(String[] args) throws IOException {
        int port = args.length == 1 ? Integer.parseInt(args[0]) : 27210;
        var address = new InetSocketAddress(InetAddress.getLoopbackAddress(), port);
        HttpServer server = HttpServer.create(address, 0);
        server.createContext("/", new Internet10()::process);
        // jede Anfrage wird von einem virtuellen Thread bearbeitet: eine langsame Anfrage blockiert die anderen nicht
        server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
        server.start();
        IO.println("Web server started on http://localhost:" + port);
    }

    // Bearbeitung einer Anfrage, dann Konsolenprotokoll: die Anfrage, der Client-Port und der Statuscode
    private void process(HttpExchange exchange) {
        String start = "%s %s %s (client port %d)".formatted(exchange.getRequestMethod(),
                exchange.getRequestURI(), exchange.getProtocol(), exchange.getRemoteAddress().getPort());
        try (exchange) {
            respond(exchange);
            IO.println(start + " -> " + exchange.getResponseCode());
        } catch (IOException e) {
            // die Verbindung wurde während des Austauschs unterbrochen
            IO.println(start + " -> error: " + e.getMessage());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // die Antwort je nach Methode und Pfad der URL
    private void respond(HttpExchange exchange) throws IOException, InterruptedException {
        String route = exchange.getRequestMethod() + " " + exchange.getRequestURI().getPath();
        // die Parameter der URL
        Map<String, String> urlParameters = parameters(exchange.getRequestURI().getRawQuery());
        switch (route) {
            // die Startseite: ein HTML-Dokument
            case "GET /", "HEAD /" -> send(exchange, 200, HOME, "text/html; charset=utf-8");
            // ein aus einem Parameter der URL erstelltes Textdokument
            case "GET /hello", "HEAD /hello" -> send(exchange, 200,
                    "Hello " + urlParameters.getOrDefault("name", "unknown") + "!", TEXT);
            // die vom Server empfangenen HTTP-Header (alphabetische Reihenfolge), als Text zurückgesendet
            case "GET /headers", "HEAD /headers" -> send(exchange, 200,
                    new TreeMap<>(exchange.getRequestHeaders()).entrySet().stream()
                            .map(header -> header.getKey() + ": " + String.join(", ", header.getValue()))
                            .collect(Collectors.joining("\n")),
                    TEXT);
            // vorübergehende Weiterleitung (302) auf eine relative Adresse
            case "GET /old", "HEAD /old" -> redirect(exchange, "/hello?name=visitor");
            // eine Weiterleitung, die sich im Kreis dreht
            case "GET /loop", "HEAD /loop" -> redirect(exchange, "/loop");
            // ein Serverfehler (500 Internal Server Error)
            case "GET /error", "HEAD /error" -> exchange.sendResponseHeaders(500, -1);
            // eine Antwort, die sich Zeit lässt: der virtuelle Thread wird während des Wartens angehalten
            case "GET /slow" -> {
                int seconds = Integer.parseInt(urlParameters.get("seconds"));
                Thread.sleep(seconds * 1000L);
                send(exchange, 200, "Response obtained after " + seconds + " s", TEXT);
            }
            // ein per POST gesendetes Formular: das Empfangene wird beschrieben
            case "POST /form" -> {
                Map<String, String> fields = parameters(readDocument(exchange));
                String type = exchange.getRequestHeaders().getFirst("Content-Type");
                String description = fields.entrySet().stream()
                        .map(field -> field.getKey() + "=[" + field.getValue() + "]")
                        .collect(Collectors.joining(", "));
                send(exchange, 200, "Content-Type received: " + type + "\nFields received: " + description,
                        TEXT);
            }
            // ein beliebiger per POST gesendeter Text: er wird in Großbuchstaben zurückgesendet
            case "POST /text" -> send(exchange, 200,
                    "Content-Type received: " + exchange.getRequestHeaders().getFirst("Content-Type")
                            + "\nText received in upper case: " + readDocument(exchange).toUpperCase(),
                    TEXT);
            // die Liste der Personen
            case "GET /api/persons" -> {
                synchronized (lock) {
                    send(exchange, 200, mapper.writeValueAsString(persons), JSON);
                }
            }
            // Hinzufügen einer Person: der Server weist ihr eine Nummer zu und antwortet mit 201 Created
            case "POST /api/persons" -> {
                Person newPerson = mapper.readValue(readDocument(exchange), Person.class);
                synchronized (lock) {
                    int id = persons.stream().mapToInt(Person::id).max().orElse(0) + 1;
                    Person created = new Person(id, newPerson.name(), newPerson.age());
                    persons.add(created);
                    exchange.getResponseHeaders().set("Location", "/api/persons/" + id);
                    send(exchange, 201, mapper.writeValueAsString(created), JSON);
                }
            }
            default -> {
                // eine durch ihre Nummer bezeichnete Person oder 404, wenn sie nicht existiert
                Matcher matcher = PERSON.matcher(route);
                if (matcher.matches()) {
                    int id = Integer.parseInt(matcher.group(1));
                    synchronized (lock) {
                        var person = persons.stream().filter(p -> p.id() == id).findFirst();
                        if (person.isPresent()) {
                            send(exchange, 200, mapper.writeValueAsString(person.get()), JSON);
                            return;
                        }
                    }
                }
                // jede andere URL liefert die Antwort 404 Not Found
                exchange.sendResponseHeaders(404, -1);
            }
        }
    }

    // Senden eines Textdokuments mit seinem Statuscode und seinem Typ; kein Dokument bei HEAD
    private void send(HttpExchange exchange, int code, String text, String type) throws IOException {
        byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
        exchange.getResponseHeaders().set("Content-Type", type);
        if (exchange.getRequestMethod().equals("HEAD")) {
            exchange.sendResponseHeaders(code, -1);
        } else {
            exchange.sendResponseHeaders(code, bytes.length);
            exchange.getResponseBody().write(bytes);
        }
    }

    // vorübergehende Weiterleitung (302): Header Location, ohne Dokument
    private void redirect(HttpExchange exchange, String address) throws IOException {
        exchange.getResponseHeaders().set("Location", address);
        exchange.sendResponseHeaders(302, -1);
    }

    // das vom Client gesendete Dokument, in UTF-8 dekodiert
    private String readDocument(HttpExchange exchange) throws IOException {
        return new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8);
    }

    // die Parameter name1=value1&name2=value2 einer URL oder eines Formulars, dekodiert
    private Map<String, String> parameters(String string) {
        Map<String, String> result = new LinkedHashMap<>();
        if (string != null && !string.isEmpty()) {
            for (String pair : string.split("&")) {
                String[] fields = pair.split("=", 2);
                result.put(URLDecoder.decode(fields[0], StandardCharsets.UTF_8),
                        fields.length == 2 ? URLDecoder.decode(fields[1], StandardCharsets.UTF_8) : "");
            }
        }
        return result;
    }
}

Anmerkungen:

  • Zeile 23: In einem Maven-Projekt schreiben wir reguläre Klassen mit ihrem Paket ([internet]) und Importen statt kompakter Quelldateien;
  • Zeilen 40–44: die Serverdaten: eine kleine „Datenbank“ von Personen, die Sperre, die sie schützt, und das Jackson-Objekt [JsonMapper] , das Objekte in JSON umwandelt und umgekehrt;
  • Zeilen 50–52: Alle URL-Objekte werden an die Methode [process] einer [Internet10]-Instanz übergeben. Standardmäßig verarbeitet der JDK-Server alle Anfragen in einem einzigen Thread: Eine langsame Anfrage würde alle anderen blockieren. Die Methode [setExecutor] versorgt ihn mit einem [ExecutorService] , der jede Anfrage in einem virtuellen Thread ausführt;
  • Zeilen 58–70: Jede Anfrage wird zusammen mit dem Port des Clients und dem Statuscode der Antwort auf der Konsole angezeigt. Anhand des Client-Ports können wir feststellen, ob zwei Anfragen dieselbe TCP-Verbindung verwendet haben;
  • Zeile 74: die „Route“ der Anfrage, bestehend aus ihrer Methode und dem Pfad der URL ([GET /hello], [POST /form] …), über die der [switch] aus Zeile 77 ausgeführt wird;
  • Zeile 79: Die URL [/] liefert ein kleines HTML-Dokument;
  • Zeile 81: Die URL [/hello?name=xx] erzeugt den Text [Hello xx!];
  • Zeile 84: Die URL [/headers] sendet die HTTP-Header der Anfrage des Clients als Text an den Client zurück, alphabetisch sortiert mithilfe einer [TreeMap]. So können wir sehen, was [HttpClient] sendet;
  • Zeilen 90–92: eine vorübergehende Umleitung auf [/hello?name=visitor] und eine Umleitung, die auf sich selbst zurückführt, wie beim Server aus dem ersten Teil;
  • Zeile 94: eine 500-Antwort (interner Serverfehler);
  • Zeilen 96–100: Die URL [/slow?seconds=n] antwortet erst, nachdem n Sekunden vergangen sind. Der virtuelle Thread, der die Anfrage verarbeitet, wird währenddessen angehalten, ohne Systemthreads zu blockieren;
  • Zeilen 102–110: Die URL [/form] empfängt ein über die Methode [POST] gesendetes Formular und beschreibt, was sie erhalten hat;
  • Zeilen 112–115: Die URL [/text] empfängt beliebigen Text über [POST] und gibt ihn in Großbuchstaben zurück;
  • Zeilen 117–148: die „Datenbank“ der Personen, die im JSON-Format ausgetauscht wird. [GET /api/persons] liefert die Liste der Personen, [GET /api/persons/n] liefert die Person Nr. n (oder eine 404-Antwort), [POST /api/persons] fügt die vom Client gesendete Person hinzu, vergibt eine Nummer und antwortet mit dem Statuscode 201 (Created) und einem Header [Location] mit der URL der neuen Person. Da mehrere Anfragen gleichzeitig von verschiedenen Threads verarbeitet werden können, wird die Liste durch eine Sperre geschützt ([synchronized], Kapitel 8). [writeValueAsString] wandelt ein Objekt in ein JSON-Dokument um; [readValue] führt die umgekehrte Operation aus;
  • Zeile 147: Jede andere URL liefert eine 404-Antwort.

Der Server wird in einem Eingabeaufforderungsfenster aus dem Ordner [Internet10] mit [mvn compile exec:java] gestartet und läuft dort während aller Tests dieses Abschnitts weiter. Die von ihm empfangenen Anfragen werden am Ende des Abschnitts vorgestellt.

12.7.2.2. Ein Dokument abrufen: send und BodyHandlers

Die Verwendung von [HttpClient] umfasst drei Typen:

  • [HttpClient]: der Client selbst, erzeugt von [HttpClient.newHttpClient()] oder, um ihn zu konfigurieren, von [HttpClient.newBuilder()...build()];
  • [HttpRequest]: eine Anfrage, die ebenfalls von einem „Konstruktor“ ([builder]) erzeugt wird: [HttpRequest.newBuilder(uri)...build()]. Sofern nichts anderes angegeben ist, handelt es sich um eine [GET]-Anfrage;
  • [HttpResponse<T>]: die Antwort, die von der Methode [send(request, handler)] des Clients zurückgegeben wird. Der zweite Parameter, ein [BodyHandler<T>], legt fest, was mit dem empfangenen Dokument geschehen soll; die Klasse [BodyHandlers] stellt die gängigen Handler bereit:
Handler
Das Dokument wird zurückgegeben als
BodyHandlers.ofString()
Zeichenkette ([HttpResponse<String>]), decodiert gemäß dem im Header [Content-Type] angegebenen Zeichensatz
BodyHandlers.ofByteArray()
Byte-Array (zum Beispiel ein Bild)
BodyHandlers.ofInputStream(), ofLines()
Byte-Strom oder Stream ([Stream<String>]) von Zeilen, die beim Eintreffen des Dokuments gelesen werden (z. B. eine große Datei)
BodyHandlers.ofFile(Path)
Datei, in der das Dokument gespeichert wird
BodyHandlers.discarding()
keines: Das Dokument wird ignoriert

Die Methode [send] ist synchron: Sie gibt die Antwort zurück, sobald deren Header und – außer bei Strömen – deren Dokument eingetroffen sind. Sie löst bei einem Kommunikationsproblem eine [IOException] aus, nicht aber bei einem Fehlerstatuscode: Eine 404-Antwort wird wie jede andere Antwort behandelt. Ihre asynchrone Version, [sendAsync], betrachten wir später.

Das Programm [Internet11.java] lautet wie folgt:

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;

// erste Schritte mit java.net.http.HttpClient: ein Dokument herunterladen
// der Testserver [Internet10] muss auf Port 27210 gestartet sein

// die Basisadresse der relativen URLs, die angefordert werden
final URI BASE = URI.create("http://localhost:27210/");

void main() throws IOException, InterruptedException {
    // ein HTTP-Client, beim Verlassen des try geschlossen (HttpClient ist seit Java 21 AutoCloseable)
    try (HttpClient client = HttpClient.newHttpClient()) {
        // 1 - ein Textdokument: GET-Anfrage, Dokument als Zeichenkette empfangen
        HttpRequest request = HttpRequest.newBuilder(BASE.resolve("hello?name=Serge")).build();
        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
        IO.println("Document received: " + response.body());

        // 2 - die von HttpClient gesendeten HTTP-Header, so wie der Server sie empfangen hat
        IO.println("--- headers sent by default");
        request = HttpRequest.newBuilder(BASE.resolve("headers")).build();
        IO.println(client.send(request, BodyHandlers.ofString()).body());

        // 3 - eine HTTP/1.1-Anfrage, mit zusätzlichen Headern
        request = HttpRequest.newBuilder(BASE.resolve("headers"))
                .version(HttpClient.Version.HTTP_1_1)
                .header("User-Agent", "java-course-client/1.0")
                .header("Accept-Language", "en-US")
                .build();
        IO.println("--- headers of an HTTP/1.1 request with User-Agent and Accept-Language");
        IO.println(client.send(request, BodyHandlers.ofString()).body());

        // 4 - ein HTML-Dokument, als Byte-Array
        request = HttpRequest.newBuilder(BASE.resolve("/")).build();
        byte[] bytes = client.send(request, BodyHandlers.ofByteArray()).body();
        IO.println("--- the home page is " + bytes.length + " bytes long");

        // 5 - ein nicht existierendes Dokument: keine Exception, das Programm muss den Statuscode prüfen
        request = HttpRequest.newBuilder(BASE.resolve("unknown")).build();
        response = client.send(request, BodyHandlers.ofString());
        IO.println("--- status code: " + response.statusCode() + ", document: [" + response.body() + "]");
    }
}

Ergebnisse (der Server [Internet10] wurde in einem anderen Fenster gestartet):

> java Internet11.java
Document received: Hello Serge!
--- headers sent by default
Connection: Upgrade, HTTP2-Settings
Host: localhost:27210
Http2-settings: AAEAAEAAAAIAAAAAAAMAAAAAAAQBAAAAAAUAAEAAAAYABgAA
Upgrade: h2c
User-agent: Java-http-client/25.0.4.1
--- headers of an HTTP/1.1 request with User-Agent and Accept-Language
Accept-language: en-US
Host: localhost:27210
User-agent: java-course-client/1.0
--- the home page is 163 bytes long
--- status code: 404, document: []

Anmerkungen:

  • Zeile 10: [HttpClient] hat keine Basisadresse für relative URL-Referenzen: Wir verwenden die Methode [resolve] der Klasse [URI], wie im Webclient aus Teil 1 gesehen, die eine relative URL ([hello?name=Serge]) anhand der Basis-URI auflöst, um [http://localhost:27210/hello?name=Serge] zu erhalten. Der abschließende Schrägstrich in der Basisadresse ist wichtig: Ohne ihn würde das letzte Segment des Pfads durch die relative URL ersetzt;
  • Zeile 14: Erzeugung des Clients. Seit Java 21 implementiert [HttpClient] das Interface [AutoCloseable]: Seine Methode [close] wartet, bis laufende Anfragen abgeschlossen sind, und gibt dann seine Ressourcen (Verbindungen, Threads) frei;
  • Zeilen 16–18: Drei Anweisungen genügen, um das Dokument abzurufen: die Anfrage erstellen, sie senden und das Antwortdokument lesen ([body]). [HttpClient] hat die HTTP-Anfrage erstellt, eine Verbindung aufgebaut, die Antwort analysiert und das Dokument dekodiert;
  • Zeilen 22–23: Die Zeilen 4–8 der Ergebnisse zeigen, was [HttpClient] standardmäßig sendet: den erforderlichen Header [Host] und einen Header [User-Agent], der die Java-Version angibt. Überraschender sind die Header [Connection: Upgrade, HTTP2-Settings], [Upgrade: h2c] und [HTTP2-Settings]: Standardmäßig bevorzugt [HttpClient] HTTP/2 und schlägt dem Server vor, auf der unverschlüsselten Verbindung zu HTTP/2 zu wechseln ([h2c]). Unser Server, der nur HTTP/1.1 kennt, ignorierte den Vorschlag und antwortete mit HTTP/1.1. Bei einer URL mit [https] wird die HTTP-Version beim Aufbau der TLS-Verbindung ausgehandelt. Außerdem fällt auf, dass der JDK-Server die empfangenen Header-Namen nur mit einem einzigen Großbuchstaben anzeigt ([User-agent]);
  • Zeilen 26–30: Eine genauer konstruierte Anfrage: die HTTP-Version (1.1, wodurch die Header für den Wechsel zu HTTP/2 entfallen) und zwei Header, die für diese Anfrage spezifisch sind. [HttpClient] kennt keine Header, die allen Anfragen gemeinsam sind: Bei Bedarf schreibt man eine Methode, die die Anfragen erstellt. Die Zeilen 10–12 der Ergebnisse zeigen, dass die Header vom Server tatsächlich empfangen wurden;
  • Zeilen 35–36: Das Dokument wird als Bytes abgerufen. Beachten Sie die URL mit [/]: Eine relative URL, die mit einem Schrägstrich beginnt, bezieht sich ausgehend von der Basisadresse auf das Stammverzeichnis der Site;
  • Zeilen 40–42: ein nicht vorhandenes Dokument. Es wird keine Ausnahme ausgelöst: Die Antwort hat den Statuscode 404 ([statusCode]) und ein leeres Dokument. Es ist Sache des Programms, den Statuscode zu prüfen.

12.7.2.3. Anfrage und Antwort: HttpRequest und HttpResponse

Betrachten wir die Konfiguration des Clients und der Anfrage sowie den Inhalt der Antwort etwas genauer:

Element
Rolle
HttpClient.newBuilder() .followRedirects(Redirect r) .connectTimeout(Duration d) .version(Version v) .executor(Executor e) .proxy(ProxySelector p) .build()
Konfiguration des Clients: Verfolgen von Weiterleitungen ([Redirect.NEVER] standardmäßig, [Redirect.NORMAL] zum Verfolgen, außer bei [https] nach [http], [Redirect.ALWAYS]), maximale Zeitspanne für den Verbindungsaufbau, bevorzugte HTTP-Version, für asynchrone Operationen verwendete Threads, Proxy …
HttpRequest.newBuilder(URI uri) .GET() .POST(BodyPublisher p) .method(String method, BodyPublisher p) .header(String name, String value) .timeout(Duration d) .version(Version v) .build()
die Anfrage: Methode und gesendetes Dokument (bei [POST] und [PUT]), Header, maximale Antwortzeit (danach [HttpTimeoutException]), HTTP-Version
HttpResponse.statusCode(), version()
der Statuscode und die (HTTP-)Version der Antwort. Es gibt keine Methode für die auf den Code folgende Meldung (sie existiert in HTTP/2 nicht mehr)
HttpResponse.headers()
die Header der Antwort, ein Objekt [HttpHeaders]: [firstValue(name)] liefert den ersten Wert eines Headers (ein [Optional<String>]), [map()] alle Header in Form eines Dictionarys: Schlüssel → Liste von Werten
HttpResponse.body()
das Dokument in dem Format, das durch den [BodyHandler] gewählt wurde
HttpResponse.uri(), request(), previousResponse()
die URI der Antwort und die zugehörige Anfrage: Bei einer Weiterleitung ist dies die zuletzt gesendete Anfrage; [previousResponse] liefert die vorherige Antwort (die Weiterleitung)

Mit diesen Klassen nehmen wir den Webclient aus Teil 1 ([Internet08.java], [Internet09.java]) wieder auf, der mit einer URL und der Methode [GET] oder [HEAD] aufgerufen wurde. Das Programm [Internet12.java] lautet wie folgt:

import java.net.http.HttpClient;
import java.net.http.HttpConnectTimeoutException;
import java.net.http.HttpHeaders;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.net.http.HttpTimeoutException;

// Web-Client auf Basis von HttpClient: zeigt den Status, die Header und das empfangene Dokument an
// Aufruf: java Internet12.java URL GET|HEAD

final String SYNTAX = "Syntax: java Internet12.java URL GET|HEAD";

void main(String[] args) throws InterruptedException {
    if (args.length != 2) {
        IO.println(SYNTAX);
        return;
    }
    // die URL muss eine absolute http- oder https-URL sein
    URI uri = parse(args[0]);
    if (uri == null) {
        IO.println("Incorrect URL [" + args[0] + "]: give a URL of the form "
                + "http://machine[:port]/document");
        return;
    }
    // die HTTP-Methode
    String command = args[1].toUpperCase();
    if (!command.equals("GET") && !command.equals("HEAD")) {
        IO.println(SYNTAX);
        return;
    }

    // höchstens 4 Anfragen pro angeforderter URL, also 3 verfolgte Weiterleitungen (standardmäßig 5 Anfragen)
    // diese Eigenschaft wird bei der ersten Verwendung von HttpClient gelesen
    System.setProperty("jdk.httpclient.redirects.retrylimit", "4");
    // der HTTP-Client: er folgt den Weiterleitungen, außer von https auf http; höchstens 5 s für die Verbindung
    try (HttpClient client = HttpClient.newBuilder()
            .followRedirects(HttpClient.Redirect.NORMAL)
            .connectTimeout(Duration.ofSeconds(5))
            .build()) {
        // die Anfrage: Methode, URL, Header, Antwort-Timeout
        HttpRequest request = HttpRequest.newBuilder(uri)
                .method(command, HttpRequest.BodyPublishers.noBody())
                .header("User-Agent", "java-course-client/1.0")
                .timeout(Duration.ofSeconds(10))
                .build();
        // sie wird gesendet und wir warten auf die Antwort
        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
        // die Statuszeile: URL der letzten Anfrage, HTTP-Version, Code
        IO.println("The server " + response.uri() + " responded: " + response.version() + " "
                + response.statusCode());
        // die Header der Antwort
        IO.println("--- headers");
        displayHeaders(response.headers());
        // das Dokument, wenn der Statuscode einen Erfolg anzeigt (200-299)
        if (response.statusCode() / 100 == 2) {
            IO.println("--- document");
            IO.println(response.body());
        }
    } catch (HttpConnectTimeoutException e) {
        IO.println("The connection could not be established within the allotted time");
    } catch (HttpTimeoutException e) {
        IO.println("The server did not respond within the allotted time");
    } catch (ConnectException e) {
        IO.println("Unable to connect to the server " + uri.getAuthority());
    } catch (IOException e) {
        IO.println(e.getClass().getSimpleName() + " : " + e.getMessage());
    }
}

// eine korrekte absolute http- oder https-URL oder null
URI parse(String url) {
    try {
        URI uri = new URI(url);
        return uri.isAbsolute() && uri.getHost() != null
                && (uri.getScheme().equals("http") || uri.getScheme().equals("https")) ? uri : null;
    } catch (URISyntaxException e) {
        return null;
    }
}

// zeigt eine Sammlung von Headern an: ein Name kann mehrere Werte haben
void displayHeaders(HttpHeaders headers) {
    headers.map().forEach((name, values) -> IO.println(name + ": " + String.join(", ", values)));
}

Anmerkungen:

  • Zeile 20: Wie in [Internet08.java] prüft das Programm, ob die URL gültig ist (Zeilen 72–80). Das Schema [https] wird diesmal akzeptiert: [HttpClient] ist in der Lage, die TLS-Aushandlung durchzuführen;
  • Zeile 35: Die Anzahl der verfolgten Weiterleitungen ist keine Eigenschaft des Clients, sondern eine Java-Systemeigenschaft, [jdk.httpclient.redirects.retrylimit], die die Gesamtzahl der für eine angeforderte URL gesendeten Anfragen begrenzt (standardmäßig 5). Dieser Wert wird einmalig gelesen, wenn [HttpClient] zum ersten Mal verwendet wird: Hier wird er programmgesteuert vor der Erstellung des Clients gesetzt, er könnte aber auch auf der Befehlszeile angegeben werden ([java -Djdk.httpclient.redirects.retrylimit=4 ...]);
  • Zeilen 37–40: Der Client folgt Weiterleitungen (jedoch nicht solchen, die von [https] auf [http] wechseln würden, wodurch die Verschlüsselung verloren ginge) und wartet bis zu 5 Sekunden auf den Aufbau einer Verbindung;
  • Zeilen 42–46: die Anfrage mit der gewünschten Methode (kein zu sendendes Dokument: [noBody()]), einem Header [User-Agent] und einer maximalen Antwortzeit von 10 Sekunden;
  • Zeile 48: Die Anfrage wird gesendet; die Antwort steht zur Verfügung, sobald ihre Header und ihr Body empfangen wurden;
  • Zeilen 50–51: die Statuszeile. [response.uri()] ist die URL der letzten Anfrage: Bei einer Weiterleitung unterscheidet sie sich von der angeforderten URL. [version()] liefert eine Konstante der Aufzählung [HttpClient.Version];
  • Zeile 54: die Header der Antwort, angezeigt durch die Methode [displayHeaders] (Zeilen 83–85). Ein Header-Name kann mehrere Werte haben: [map()] ordnet jedem Namen die Liste seiner Werte zu;
  • Zeilen 56–59: Das Dokument wird nur angezeigt, wenn der Statuscode einen Erfolg anzeigt (Familie 2xx);
  • Zeilen 60–68: Fehler. [HttpConnectTimeoutException] (Verbindung nicht innerhalb der Frist aufgebaut) ist eine Art von [HttpTimeoutException] (Antwort nicht innerhalb der Frist empfangen), die ihrerseits eine Art von [IOException] ist: Der [catch], der zur spezifischsten Klasse gehört, muss zuerst stehen. Eine abgelehnte Verbindung führt zu einer [ConnectException].

Fordern wir die Wurzel der Site an:

> java Internet12.java http://localhost:27210/ GET
The server http://localhost:27210/ responded: HTTP_1_1 200
--- headers
content-length: 163
content-type: text/html; charset=utf-8
date: Sat, 03 Oct 2026 17:42:17 GMT
--- document
<!DOCTYPE html>
<html lang="en">
<head><meta charset="utf-8"><title>Test server</title></head>
<body><h1>Welcome to the HttpClient test server</h1></body>
</html>

Wir finden die Informationen wieder, die wir durch eigene Analyse der Antwort mit dem TCP-Client erhalten haben: die Statuszeile, die Antwort-Header [Content-Length], [Content-Type] und [Date], gefolgt vom Dokument. [HttpClient] listet die Header-Namen in Kleinbuchstaben auf: Dies ist das von HTTP/2 vorgeschriebene Format, und [HttpHeaders] sucht ohnehin ohne Beachtung der Groß- und Kleinschreibung.

Eine URL, die einer Weiterleitung unterliegt:

1
2
3
4
5
6
7
8
> java Internet12.java http://localhost:27210/old GET
The server http://localhost:27210/hello?name=visitor responded: HTTP_1_1 200
--- headers
content-length: 14
content-type: text/plain; charset=utf-8
date: Sat, 03 Oct 2026 17:42:18 GMT
--- document
Hello visitor!

Die Weiterleitung wurde automatisch verfolgt: Die empfangene Antwort ist die der URL [/hello?name=visitor] (Zeile 2). Vergleichen wir dies mit dem ersten Teil: Der Client [Internet09.java] musste die Statuszeile lesen, den Code extrahieren, den Header [Location] nachschlagen, die neue URL berechnen und den Vorgang in einer auf drei Weiterleitungen begrenzten Schleife wiederholen. Hier übernimmt [HttpClient] das alles. Um die Weiterleitungen selbst zu behandeln, rufen Sie einfach [followRedirects] nicht auf: Die Antwort 302 wird dann unverändert zurückgegeben.

Ein nicht vorhandenes Dokument:

1
2
3
4
5
> java Internet12.java http://localhost:27210/unknown GET
The server http://localhost:27210/unknown responded: HTTP_1_1 404
--- headers
content-length: 0
date: Sat, 03 Oct 2026 17:42:18 GMT

Der Code 404 ist samt seinen Headern in der Antwort enthalten; das Dokument wird nicht angezeigt. Es wurde keine Ausnahme ausgelöst: Es ist Sache des Programms, zu entscheiden, was mit einer Fehlerantwort geschehen soll.

Die URL [/loop], die auf sich selbst weiterleitet:

1
2
3
4
5
> java Internet12.java http://localhost:27210/loop HEAD
The server http://localhost:27210/loop responded: HTTP_1_1 302
--- headers
date: Sat, 03 Oct 2026 17:42:19 GMT
location: /loop

Nach vier Anfragen – das heißt drei Weiterleitungen – gibt [HttpClient] auf und liefert die zuletzt empfangene Antwort zurück, eine Antwort 302.

Ein Serverfehler:

1
2
3
4
> java Internet12.java http://localhost:27210/error HEAD
The server http://localhost:27210/error responded: HTTP_1_1 500
--- headers
date: Sat, 03 Oct 2026 17:42:19 GMT

Ein Port, auf dem kein Server lauscht:

> java Internet12.java http://localhost:27299/ GET
Unable to connect to the server localhost:27299

Die Verbindung wurde abgelehnt ([ConnectException]). Zum Schluss eine URL [https] an unseren Server, der nur HTTP im Klartext spricht:

> java Internet12.java https://localhost:27210/ GET
The connection could not be established within the allotted time

Der Client hat die erste Nachricht der Aushandlung gesendet, TLS; unser Server, der eine Anfragezeile (HTTP) erwartete, hat sie nicht verstanden und nicht geantwortet. Nach 5 Sekunden, da die sichere Verbindung nicht zustande gekommen war, lief die Frist für den Verbindungsaufbau ab. Auf einem mit dem Internet verbundenen Rechner würde eine Anfrage wie die URL [https://dev.java/] normalerweise als HTTP/2 bedient, sofern der Server dies zulässt.

Eine letzte Anmerkung zu Proxys: Das sind die Rechner, über die Arbeitsplätze in einem Firmennetzwerk häufig gehen müssen, um auf das Web zuzugreifen. Standardmäßig verwendet [HttpClient] den Proxy, der durch die Systemeigenschaften der virtuellen Maschine [http.proxyHost], [http.proxyPort], [https.proxyHost] und [https.proxyPort] festgelegt ist (und keinen, wenn sie nicht definiert sind). Einen anderen können Sie mit der Methode [proxy] des Client-Konstruktors angeben: [HttpClient.newBuilder().proxy(ProxySelector.of(new InetSocketAddress("proxy.example.org", 3128)))].

12.7.2.4. Daten an den Server senden: GET und POST

Ein Client kann Informationen auf zwei Arten an den Server senden:

  • mit der Methode [GET] sind die Informationen Teil der URL: [/document?param1=value1&param2=value2];
  • Mit der Methode [POST] bilden sie das der Anfrage beigefügte Dokument, das auf die Leerzeile folgt, die die Header abschließt. Der Header [Content-Type] gibt sein Format an. Bei einem HTML-Formular hat das Dokument dasselbe Format wie der Parameterteil einer URL: [param1=value1&param2=value2], mit dem Typ [application/x-www-form-urlencoded].

In beiden Fällen müssen die Werte kodiert werden: Bestimmte Zeichen (das Leerzeichen, [&], [=], [?], Buchstaben mit Akzent usw.) dürfen nicht unverändert in einer URL oder einem Formular vorkommen. Dazu verwendet man die statische Methode [URLEncoder.encode(value, charset)], die das Formularformat erzeugt; [URLDecoder.decode], das unsere Testserver verwenden, führt die umgekehrte Operation aus.

Das zu sendende Dokument wird der Anfrage über einen [BodyPublisher] übergeben; die Klasse [BodyPublishers] stellt die gängigsten bereit:

Methode
Gesendetes Dokument
BodyPublishers.ofString(String text[, Charset charset])
Text, standardmäßig in UTF-8 kodiert. Der Dokumenttyp wird durch einen der Anfrage hinzugefügten Header [Content-Type] angegeben: [text/plain], [application/json], [application/x-www-form-urlencoded] …
BodyPublishers.ofByteArray(byte[] bytes), ofFile(Path path), ofInputStream(...)
beliebige Bytes, eine Datei, ein Stream
BodyPublishers.noBody()
kein Dokument

Im JDK gibt es keine Klasse, die ein Formular konstruiert: Sie bauen den String [name=value&...] selbst zusammen. Das Programm [Internet13.java] lautet wie folgt:

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;

import static java.nio.charset.StandardCharsets.UTF_8;

// Daten an den Server senden: URL-Parameter (GET), Formular und Text (POST)
// der Testserver [Internet10] muss auf Port 27210 gestartet sein

final URI BASE = URI.create("http://localhost:27210/");

void main() throws IOException, InterruptedException {
    try (HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build()) {
        // 1 - GET: die Parameter sind Teil der URL; sie müssen darin kodiert werden
        String name = "Jean & Marie";
        String url = "hello?name=" + URLEncoder.encode(name, UTF_8);
        IO.println("--- GET " + url);
        HttpRequest request = HttpRequest.newBuilder(BASE.resolve(url)).build();
        IO.println(client.send(request, BodyHandlers.ofString()).body());

        // 2 - POST eines Formulars: die Parameter bilden das an den Server gesendete Dokument
        List<Map.Entry<String, String>> fields = List.of(
                Map.entry("name", "Jean & Marie"),
                Map.entry("age", "42"),
                Map.entry("city", "Angers"));
        // das Dokument: name=value&name=value..., Namen und Werte kodiert
        String form = fields.stream()
                .map(field -> URLEncoder.encode(field.getKey(), UTF_8) + "="
                        + URLEncoder.encode(field.getValue(), UTF_8))
                .collect(Collectors.joining("&"));
        IO.println("--- POST form, document sent: " + form);
        request = HttpRequest.newBuilder(BASE.resolve("form"))
                .header("Content-Type", "application/x-www-form-urlencoded")
                .POST(BodyPublishers.ofString(form))
                .build();
        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
        IO.println(response.statusCode() + " : " + response.body());

        // 3 - POST eines beliebigen Textes, mit seinem Typ und seiner Kodierung
        IO.println("--- POST text");
        request = HttpRequest.newBuilder(BASE.resolve("text"))
                .header("Content-Type", "text/plain; charset=utf-8")
                .POST(BodyPublishers.ofString("naïve café", UTF_8))
                .build();
        response = client.send(request, BodyHandlers.ofString());
        IO.println(response.statusCode() + " : " + response.body());
    }
}

Ergebnisse:

1
2
3
4
5
6
7
8
9
> java Internet13.java
--- GET hello?name=Jean+%26+Marie
Hello Jean & Marie!
--- POST form, document sent: name=Jean+%26+Marie&age=42&city=Angers
200 : Content-Type received: application/x-www-form-urlencoded
Fields received: name=[Jean & Marie], age=[42], city=[Angers]
--- POST text
200 : Content-Type received: text/plain; charset=utf-8
Text received in upper case: NAÏVE CAFÉ

Anmerkungen:

  • Zeilen 17–18: Der Wert [Jean & Marie] wird in die URL eingefügt. Ohne Kodierung würde das Zeichen [&] als Trennzeichen zwischen zwei Parametern interpretiert, und der Server würde den Parameter [name] mit dem Wert [Jean] erhalten. In Zeile 2 der Ergebnisse sehen wir, dass das Leerzeichen zu [+] und das Zeichen [&] zu [%26] geworden ist: Das ist der hexadezimale Code des Zeichens, dem [%] vorangestellt ist. [URLEncoder] erzeugt das Formularformat, in dem das Leerzeichen als [+] kodiert wird; im Pfad einer URL wäre [%20] erforderlich, im Parameterteil akzeptieren die Server jedoch beides;
  • Zeilen 24–27: die Formularfelder in Form einer Liste von (Name, Wert)-Paaren, erzeugt durch [Map.entry]. Eine Liste behält die Reihenfolge der Felder bei, was ein Dictionary [Map.of] nicht tun würde;
  • Zeilen 29–32: Das Dokument wird mit der Stream-API aufgebaut: Jedes Paar wird zu [name=value], wobei Namen und Werte kodiert werden, und die Paare werden durch [&] verbunden. Zeile 4 der Ergebnisse zeigt das Format [name=value&name=value];
  • Zeilen 34–37: Das Formular wird mit der Methode [POST] an die URL [/form] gesendet, zusammen mit seinem Typ. Der Server zeigt an (Zeilen 5–6 der Ergebnisse), dass er ein Dokument vom Typ [application/x-www-form-urlencoded] erhalten und daraus die drei Felder extrahiert und dekodiert hat;
  • Zeilen 43–46: Text in UTF-8-Kodierung vom Typ [text/plain]. Der Server gibt ihn in Großbuchstaben zurück (Zeile 9 der Ergebnisse): Die Zeichen mit Akzent wurden korrekt übertragen und empfangen.

Rufen wir uns den Unterschied zwischen [GET] und [POST] in Erinnerung: Ein Browser zeigt die Parameter einer [GET]-Anfrage in seiner Adressleiste an, nicht aber die einer [POST]-Anfrage; außerdem sollte eine [GET]-Anfrage nur zum Abrufen von Informationen verwendet werden, während eine [POST]-Anfrage dazu dient, Informationen zu senden oder den Zustand des Servers zu ändern.

12.7.2.5. Objekte im JSON-Format austauschen

Anwendungen tauschen heute den Großteil ihrer Daten im JSON-Format aus, das in Kapitel 5 beschrieben wurde. Das JDK besitzt keine JSON-Bibliothek: [HttpClient] transportiert JSON-Dokumente als Zeichenketten, und für die Umwandlung zwischen Objekten und JSON wird Jackson verwendet:

  • Auf der Senderseite erzeugt [mapper.writeValueAsString(object)] das JSON-Dokument, das [BodyPublishers.ofString] mit dem Header [Content-Type: application/json] sendet;
  • Auf der Empfängerseite wandelt [mapper.readValue(json, Type.class)] das empfangene JSON-Dokument in ein Objekt um. Für einen generischen Typ wie [List<Person>] verwendet man eine [TypeReference], die den Typparameter erhält, den Java bei der Kompilierung entfernt.

Das Programm [Internet14] ist ein Maven-Projekt, in dem sich die Datei [pom.xml] von der des Servers [Internet10] nur im Projektnamen ([internet14]) und in der Hauptklasse ([internet.Internet14]) unterscheidet. Es enthält dasselbe Record [Person] wie der Server. Die Klasse [Internet14] lautet wie folgt:

package internet;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.util.List;
import tools.jackson.core.type.TypeReference;
import tools.jackson.databind.json.JsonMapper;

// Objekte im JSON-Format mit einem Webserver austauschen
// der Testserver [Internet10] muss auf Port 27210 gestartet sein
public class Internet14 {

    private static final URI BASE = URI.create("http://localhost:27210/");
    // der Jackson-Konverter Objekte <-> JSON
    private static final JsonMapper MAPPER = JsonMapper.builder().build();

    public static void main(String[] args) throws IOException, InterruptedException {
        try (HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build()) {
            // 1 - die Liste der Personen: das JSON-Dokument wird in eine Liste von Objekten umgewandelt
            List<Person> persons = readJson(client, "api/persons", new TypeReference<List<Person>>() {
            });
            IO.println("--- list of persons");
            persons.forEach(IO::println);

            // 2 - eine Person
            Person durand = readJson(client, "api/persons/2", new TypeReference<Person>() {
            });
            IO.println("--- person no. 2: " + durand);

            // 3 - Hinzufügen einer Person: das Objekt wird im JSON-Format gesendet
            var martin = new Person(0, "Martin", 25);
            HttpRequest request = HttpRequest.newBuilder(BASE.resolve("api/persons"))
                    .header("Content-Type", "application/json")
                    .POST(HttpRequest.BodyPublishers.ofString(MAPPER.writeValueAsString(martin)))
                    .build();
            HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
            IO.println("--- addition of " + martin);
            IO.println("Status: " + response.statusCode() + ", Location: "
                    + response.headers().firstValue("Location").orElse("?"));
            // das empfangene JSON-Dokument, roh und dann als Objekt
            IO.println("JSON received: " + response.body());
            Person created = MAPPER.readValue(response.body(), Person.class);
            IO.println("Person created: " + created);

            // 4 - eine Person, die nicht existiert
            try {
                readJson(client, "api/persons/99", new TypeReference<Person>() {
                });
            } catch (IOException e) {
                IO.println("--- person no. 99: " + e.getClass().getSimpleName() + " : " + e.getMessage());
            }
        }
    }

    // GET [path] und Umwandlung des empfangenen JSON-Dokuments in ein Objekt vom Typ T
    // wirft eine IOException, wenn der Statuscode keinen Erfolg anzeigt
    private static <T> T readJson(HttpClient client, String path, TypeReference<T> type)
            throws IOException, InterruptedException {
        HttpRequest request = HttpRequest.newBuilder(BASE.resolve(path))
                .header("Accept", "application/json")
                .build();
        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
        if (response.statusCode() / 100 != 2) {
            throw new IOException("GET " + response.uri() + " : status code " + response.statusCode());
        }
        return MAPPER.readValue(response.body(), type);
    }
}

Ergebnisse (aus dem Ordner [Internet14]):

> mvn compile exec:java
--- list of persons
Person[id=1, name=Dupont, age=42]
Person[id=2, name=Durand, age=35]
--- person no. 2: Person[id=2, name=Durand, age=35]
--- addition of Person[id=0, name=Martin, age=25]
Status: 201, Location: /api/persons/3
JSON received: {"id":3,"name":"Martin","age":25}
Person created: Person[id=3, name=Martin, age=25]
--- person no. 99: IOException : GET http://localhost:27210/api/persons/99 : status code 404

Anmerkungen:

  • Zeile 19: Der [JsonMapper] von Jackson wird einmalig erstellt; er kann von mehreren Threads gleichzeitig verwendet werden;
  • Zeilen 61–71: Die generische Methode [readJson] leistet das Äquivalent einer Methode, die „eine URL anfordert und das empfangene JSON-Dokument in ein Objekt umwandelt“: Sie sendet die Anfrage [GET] mit dem Header [Accept: application/json], prüft den Statuscode (Zeile 67) und wandelt das Dokument in ein Objekt des angeforderten Typs um (Zeile 70);
  • Zeilen 24–25: die Liste der Personen. Das vom Server gesendete JSON-Dokument [[{"id":1,"name":"Dupont","age":42},...]] wird direkt in eine Liste von Objekten [Person] umgewandelt. Der Ausdruck [new TypeReference<List<Person>>() {}] erzeugt eine Instanz einer anonymen Klasse, die von [TypeReference] abgeleitet ist: Das ist der Kniff, mit dem Jackson zur Laufzeit den Typ [List<Person>] bestimmen kann;
  • Zeile 27: Jede Person wird mit der für das Record generierten Methode [toString] angezeigt;
  • Zeilen 30–31: eine einzelne Person;
  • Zeilen 35–40: Das Objekt [martin] wird in JSON umgewandelt und per [POST] an den Server gesendet. Der Server antwortet mit dem Statuscode 201 (Created) und dem Header [Location], der die URL der neuen Ressource angibt (Zeile 7 der Ergebnisse);
  • Zeilen 45–46: das empfangene JSON-Dokument, zuerst in Rohform und dann in ein Objekt umgewandelt. Die Eigenschaftsnamen sind die der Komponenten des Records ([id], [name], [age]), gemäß den Web-Konventionen im „camelCase“ formatiert;
  • Zeilen 50–55: eine nicht vorhandene Person: [readJson] löst bei einer Antwort 404 eine [IOException] aus.

Auf diese Techniken kommen wir im nächsten Kapitel zurück, in dem der Steuerberechnungsserver zu einem JSON-Webservice wird.

12.7.2.6. Timeout, Abbruch und Wiederverwendung des Clients

Das Programm [Internet15.java] veranschaulicht vier wichtige Punkte für den Einsatz von [HttpClient] in einer realen Anwendung: Wiederverwendung des Clients, Timeouts, Abbruch von Anfragen und asynchrone Anfragen. Die Methode [sendAsync] von [HttpClient] ist die asynchrone Version von [send]: Sie sendet die Anfrage und gibt sofort ein [CompletableFuture<HttpResponse<T>>] (Kapitel 9) zurück, das abgeschlossen wird, sobald die Antwort eintrifft. Das Programm lautet wie folgt:

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.net.http.HttpTimeoutException;

// Timeout, Abbruch und Wiederverwendung eines HttpClient; asynchrone Anfragen (sendAsync)
// der Testserver [Internet10] muss auf Port 27210 gestartet sein

final URI BASE = URI.create("http://localhost:27210/");

void main() throws IOException, InterruptedException {
    // 1 - eine einzige HttpClient-Instanz für die ganze Anwendung
    try (HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build()) {

        // 2 - aufeinanderfolgende Anfragen: dieselbe TCP-Verbindung wird wiederverwendet
        IO.println("--- three successive requests");
        for (int i = 1; i <= 3; i++) {
            IO.println(client.send(request("hello?name=trial" + i), BodyHandlers.ofString()).body());
        }

        // 3 - eine innerhalb des 2-s-Timeouts erhaltene Antwort, dann eine zu langsame Antwort
        for (int seconds : List.of(1, 3)) {
            IO.println("--- response expected in " + seconds + " s");
            try {
                IO.println(client.send(request("slow?seconds=" + seconds), BodyHandlers.ofString()).body());
            } catch (HttpTimeoutException e) {
                IO.println(e.getClass().getSimpleName() + " : " + e.getMessage());
            }
        }

        // 4 - eine asynchrone Anfrage, vom Programm nach einer halben Sekunde abgebrochen
        IO.println("--- cancellation after 0.5 s");
        CompletableFuture<HttpResponse<String>> future =
                client.sendAsync(request("slow?seconds=1"), BodyHandlers.ofString());
        CompletableFuture.delayedExecutor(500, TimeUnit.MILLISECONDS).execute(() -> future.cancel(true));
        try {
            IO.println(future.join().body());
        } catch (CancellationException e) {
            IO.println("Request cancelled (" + e.getClass().getSimpleName() + ")");
        }

        // 5 - vier gleichzeitige asynchrone Anfragen mit demselben Client
        IO.println("--- four simultaneous requests of one second each");
        long start = System.nanoTime();
        List<CompletableFuture<String>> responses = IntStream.rangeClosed(1, 4)
                .mapToObj(_ -> client.sendAsync(request("slow?seconds=1"), BodyHandlers.ofString())
                        .thenApply(HttpResponse::body))
                .toList();
        // wir warten auf das Ende der vier Anfragen
        CompletableFuture.allOf(responses.toArray(CompletableFuture[]::new)).join();
        responses.forEach(response -> IO.println(response.join()));
        IO.println("Total duration: %.1f s".formatted((System.nanoTime() - start) / 1e9));
    }
}

// eine GET-Anfrage an eine zu BASE relative URL: höchstens 2 Sekunden bis zur Antwort
HttpRequest request(String url) {
    return HttpRequest.newBuilder(BASE.resolve(url)).timeout(Duration.ofSeconds(2)).build();
}

Ergebnisse:

> java Internet15.java
--- three successive requests
Hello trial1!
Hello trial2!
Hello trial3!
--- response expected in 1 s
Response obtained after 1 s
--- response expected in 3 s
HttpTimeoutException : request timed out
--- cancellation after 0.5 s
Request cancelled (CancellationException)
--- four simultaneous requests of one second each
Response obtained after 1 s
Response obtained after 1 s
Response obtained after 1 s
Response obtained after 1 s
Total duration: 1.0 s

Anmerkungen:

  • Zeile 14: Das gesamte Programm verwendet eine einzige Instanz von [HttpClient]. Das ist die Regel: Ein Objekt [HttpClient] verwaltet einen Pool von Verbindungen und verwendet sie von einer Anfrage zur nächsten wieder; es ist auf Langlebigkeit ausgelegt und kann von mehreren Threads gleichzeitig verwendet werden. Für jede Anfrage einen [HttpClient] zu erstellen, ist ein häufiger Fehler: Jede Instanz öffnet ihre eigenen Verbindungen, die das System nach dem Schließen noch eine Zeit lang in Reserve hält (TIME_WAIT-Zustand von TCP); ein Programm, das viele Anfragen stellt, erschöpft schließlich die verfügbaren Ports. In jedem der vorherigen Programme haben wir einen Client erstellt, weil sie vor ihrem Ende nur wenige Anfragen stellten;
  • Zeilen 58–60: Jede Anfrage muss spätestens innerhalb von 2 Sekunden eine Antwort erhalten;
  • Zeilen 18–20: drei aufeinanderfolgende Anfragen. Im Server-Log werden wir sehen, dass sie dieselbe TCP-Verbindung verwendet haben;
  • Zeilen 23–30: eine Antwort, die nach 1 Sekunde eintrifft, gefolgt von einer Antwort, die 3 Sekunden dauern würde; nach 2 Sekunden wird die Anfrage abgebrochen und eine [HttpTimeoutException] wird ausgelöst (Zeile 9 der Ergebnisse);
  • Zeilen 34–41: ein vom Programm veranlasster Abbruch. Die Anfrage wird asynchron durch [sendAsync] gestartet, das sofort ein [CompletableFuture] zurückgibt. Ein verzögerter Executor ([CompletableFuture.delayedExecutor]) wird angewiesen, nach einer halben Sekunde seine Methode [cancel] aufzurufen; in einer interaktiven Anwendung wäre das die Wirkung einer Schaltfläche [Cancel]. Seit Java 16 beendet das Abbrechen eines von [sendAsync] zurückgegebenen [CompletableFuture] den Austausch mit dem Server tatsächlich. [join] wartet auf das Ergebnis; bei einer abgebrochenen Anfrage löst es eine [CancellationException] aus;
  • Zeilen 46–49: vier gleichzeitig auf demselben Client gestartete Anfragen: Jedes [sendAsync] gibt sofort sein [CompletableFuture] zurück, das durch [thenApply] in ein [CompletableFuture<String>] umgewandelt wird, das das Dokument liefern wird. Das anonyme Muster [_] (Java 22) ersetzt den nicht benötigten Lambda-Parameter;
  • Zeile 51: [CompletableFuture.allOf] (Kapitel 9) gibt ein abgeschlossenes [CompletableFuture] zurück, wenn alle vier abgeschlossen sind; darauf wartet [join]. Jede Anfrage benötigt auf dem Server eine Sekunde zur Verarbeitung; der gesamte Vorgang dauerte eine Sekunde (Zeile 17 der Ergebnisse): Die Anfragen wurden sowohl vom Client als auch vom Server parallel verarbeitet.

Mit virtuellen Threads lässt sich derselbe Grad an Parallelität auch ohne [sendAsync] erreichen: Man führt einfach vier Aufrufe der synchronen Methode [send] in vier virtuellen Threads aus. Beide Ansätze sind gültig; [sendAsync] ist praktisch, wenn Antworten mit anderen asynchronen Abläufen verkettet werden sollen.

Das Log des Servers [Internet10] zeigt alle seit Beginn dieses Abschnitts empfangenen Anfragen:

> mvn compile exec:java
Web server started on http://localhost:27210
GET /hello?name=Serge HTTP/1.1 (client port 47338) -> 200
GET /headers HTTP/1.1 (client port 47338) -> 200
GET /headers HTTP/1.1 (client port 47338) -> 200
GET / HTTP/1.1 (client port 47338) -> 200
GET /unknown HTTP/1.1 (client port 47338) -> 404
GET / HTTP/1.1 (client port 47352) -> 200
GET /old HTTP/1.1 (client port 41552) -> 302
GET /hello?name=visitor HTTP/1.1 (client port 41552) -> 200
GET /unknown HTTP/1.1 (client port 41560) -> 404
HEAD /loop HTTP/1.1 (client port 41576) -> 302
HEAD /loop HTTP/1.1 (client port 41592) -> 302
HEAD /loop HTTP/1.1 (client port 41596) -> 302
HEAD /loop HTTP/1.1 (client port 41610) -> 302
HEAD /error HTTP/1.1 (client port 41622) -> 500
GET /hello?name=Jean+%26+Marie HTTP/1.1 (client port 41634) -> 200
POST /form HTTP/1.1 (client port 41634) -> 200
POST /text HTTP/1.1 (client port 41634) -> 200
GET /api/persons HTTP/1.1 (client port 41638) -> 200
GET /api/persons/2 HTTP/1.1 (client port 41638) -> 200
POST /api/persons HTTP/1.1 (client port 41638) -> 201
GET /api/persons/99 HTTP/1.1 (client port 41638) -> 404
GET /hello?name=trial1 HTTP/1.1 (client port 41654) -> 200
GET /hello?name=trial2 HTTP/1.1 (client port 41654) -> 200
GET /hello?name=trial3 HTTP/1.1 (client port 41654) -> 200
GET /slow?seconds=1 HTTP/1.1 (client port 41654) -> 200
GET /slow?seconds=3 HTTP/1.1 (client port 41654) -> 200
GET /slow?seconds=1 HTTP/1.1 (client port 40736) -> 200
GET /slow?seconds=1 HTTP/1.1 (client port 40744) -> 200
GET /slow?seconds=1 HTTP/1.1 (client port 40758) -> 200
GET /slow?seconds=1 HTTP/1.1 (client port 40748) -> 200
GET /slow?seconds=1 HTTP/1.1 (client port 40760) -> 200
  • Zeilen 3–7: Die fünf Anfragen von [Internet11.java] trafen über dieselbe Verbindung ein (derselbe Client-Port): Der Client hat sie zwischen den Anfragen offen gehalten;
  • Zeilen 9–10: die weitergeleitete Anfrage von [Internet12.java] und die Anfrage an die neue Adresse, die automatisch über dieselbe Verbindung erfolgte;
  • Zeilen 12–15: die ursprüngliche Anfrage an [/loop] und die drei darauffolgenden Weiterleitungen, bevor die Verbindung aufgegeben wurde;
  • Zeilen 17–19: die Anfragen von [Internet13.java] über dieselbe Verbindung;
  • Zeilen 20–23: Anfragen an [Internet14];
  • Zeilen 24–28: Die aufeinanderfolgenden Anfragen von [Internet15.java] verwendeten alle dieselbe Verbindung. Die Anfrage, die zu lange dauerte (Zeile 28), wurde vom Client nach 2 Sekunden abgebrochen: [HttpClient] schloss die Verbindung daraufhin. Der Server bemerkte dies nicht: Nach 3 Sekunden schrieb er seine Antwort auf eine Verbindung, die der Client bereits geschlossen hatte, und das System meldet für einen solchen Schreibvorgang keinen Fehler. Deshalb zeigt das Log den Statuscode 200.
  • Zeile 29: Die vom Programm abgebrochene Anfrage muss eine neue Verbindung geöffnet haben, da die vorherige geschlossen worden war. Auch hier antwortete der Server, ohne zu wissen, dass die Antwort nicht gelesen werden würde;
  • die letzten vier Zeilen: Die vier gleichzeitigen Anfragen verwendeten vier verschiedene Verbindungen, die eigens dafür geöffnet wurden. Bei HTTP/1.1 transportiert eine Verbindung jeweils nur eine Anfrage; HTTP/2 würde es erlauben, alle über eine einzige Verbindung zu senden.

Ein Programm, das lange läuft (ein Server, ein Systemdienst), muss noch einen letzten Punkt berücksichtigen: Ein [HttpClient] hält seine inaktiven Verbindungen eine gewisse Zeit lang offen (standardmäßig 30 Sekunden, einstellbar über die Systemeigenschaft [jdk.httpclient.keepalive.timeout]), bevor er sie schließt. In Spring-Anwendungen können Sie auch den HTTP-Client des Frameworks verwenden, [RestClient] (aufbauend auf [HttpClient] oder einer anderen Bibliothek), der die automatische Umwandlung von Objekten in JSON hinzufügt; die Clients im nächsten Kapitel hingegen verwenden einfach [HttpClient] und Jackson, genau wie [Internet14].

12.7.3. Anwendung: Ein Proxy-Client für einen Web-Übersetzungsdienst

Wir zeigen nun, wie [HttpClient] die Nutzung von Webressourcen ermöglicht, selbst wenn diese Ressourcen nicht für die Verwendung durch ein Programm gedacht waren.

12.7.3.1. Die Anwendung

In den 2000er-Jahren gab es im Web kostenlose Übersetzungsseiten. Der Benutzer gab einen Text ein, wählte in einer Dropdown-Liste eine Übersetzungsrichtung („Französisch nach Englisch“ usw.), klickte auf eine Schaltfläche und erhielt eine HTML-Seite mit der Übersetzung. Sie können eine Klasse [TranslationService] schreiben, die dasselbe programmatisch erledigt: Sie erstellt die URL der Anfrage, fragt die Seite ab und extrahiert mithilfe eines regulären Ausdrucks die Übersetzung aus der empfangenen HTML-Seite. Eine grafische Oberfläche oder ein anderes Programm kann sich dann auf diese Klasse stützen; man spricht hier von einem „Proxy“-Client: Die Klasse [TranslationService] fungiert als Stellvertreter der Website und verbirgt sie vor ihrem Benutzer.

Da unser Testrechner keinen Internetzugang hat, ersetzen wir die Website durch eine kleine lokale Seite, die jene aus dieser Zeit nachahmt: Sie hat dasselbe Formular (ein Textfeld, eine Dropdown-Liste der Übersetzungsrichtungen im alten Stil) und zeigt die Übersetzung an derselben Stelle ihrer Seite an. Ihre „Übersetzungen“ erfolgen Wort für Wort anhand kleiner Wörterbücher: Uns interessiert die Technik des Clients, nicht die Qualität der Übersetzung. Der Client wird von einem Konsolen-Testprogramm verwendet. Die Architektur sieht wie folgt aus:

Image

12.7.3.2. Die Übersetzungsseite

Das Programm [Internet16.java] sieht wie folgt aus:

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;

import static java.nio.charset.StandardCharsets.UTF_8;

// eine kleine Wort-für-Wort-"Übersetzungs"-Website, die eine Übersetzungsseite der 2000er-Jahre nachahmt
// Aufruf: java Internet16.java [port]   (standardmäßig Port 27220); Stopp mit Ctrl-C

// eine Übersetzungsrichtung: ihr Label und ihr Wörterbuch
record Translator(String label, Map<String, String> words) {
}

// die Übersetzungsrichtungen: Code -> Übersetzer (LinkedHashMap: die Einfügereihenfolge bleibt erhalten)
final Map<String, Translator> translationDirections = new LinkedHashMap<>();
// ein Wort, eventuell gefolgt von einem Apostroph
final Pattern WORD = Pattern.compile("\\p{L}+'?");

void main(String[] args) throws IOException {
    int port = args.length == 1 ? Integer.parseInt(args[0]) : 27220;
    translationDirections.put("fe", new Translator("French to English", Map.of(
            "ce", "this", "chien", "dog", "est", "is", "perdu", "lost", "malade", "sick",
            "l'", "the ", "été", "summer", "sera", "will be", "chaud", "hot")));
    translationDirections.put("ef", new Translator("English to French", Map.of(
            "my", "mon", "tailor", "tailleur", "is", "est", "rich", "riche",
            "this", "ce", "dog", "chien", "lost", "perdu")));
    translationDirections.put("fs", new Translator("French to Spanish", Map.of(
            "ce", "este", "chien", "perro", "est", "está", "perdu", "perdido",
            "l'", "el ", "été", "verano", "sera", "será", "chaud", "caliente")));

    HttpServer server = HttpServer.create(new InetSocketAddress(InetAddress.getLoopbackAddress(), port), 0);
    server.createContext("/translation", this::translate);
    server.start();
    IO.println("Translation service started on http://localhost:" + port + "/translation");
}

// die Übersetzungsseite: das Formular, gefolgt von der Übersetzung, wenn ein Text angegeben wurde
void translate(HttpExchange exchange) throws IOException {
    try (exchange) {
        Map<String, String> parameters = parameters(exchange.getRequestURI().getRawQuery());
        String direction = parameters.get("direction");
        String text = parameters.getOrDefault("text", "");
        var page = new StringBuilder("""
                <!DOCTYPE html>
                <html lang="en">
                <head><meta charset="utf-8"><title>Translator of the Java course</title></head>
                <body>
                <h1>Translation of texts</h1>
                <form action="/translation" method="get">
                <textarea name="text" rows="4" cols="60"></textarea>
                <select name="direction">
                """);
        // die Liste der Übersetzungsrichtungen, auf die alte Art geschrieben: nicht geschlossene <option>-Tags
        translationDirections.forEach((code, translator) -> page.append("    <option value='").append(code)
                .append("'>").append(translator.label()).append('\n'));
        page.append("""
                </select>
                <input type="submit" value="Translate">
                </form>
                """);
        // die Übersetzung, wenn es einen zu übersetzenden Text gibt
        if (!text.isBlank()) {
            Translator translator = direction == null ? null : translationDirections.get(direction);
            if (translator != null) {
                // Wort-für-Wort-Übersetzung; ein unbekanntes Wort bleibt unverändert
                String translation = WORD.matcher(text.strip().toLowerCase())
                        .replaceAll(word -> Matcher.quoteReplacement(
                                translator.words().getOrDefault(word.group(), word.group())));
                page.append("<strong>Translated text: </strong><div class=\"txtTrans\">")
                        .append(encodeHtml(translation)).append("</div>\n");
            } else {
                page.append("<p>Unknown translation direction</p>\n");
            }
        }
        page.append("</body>\n</html>\n");
        byte[] bytes = page.toString().getBytes(UTF_8);
        exchange.getResponseHeaders().set("Content-Type", "text/html; charset=utf-8");
        exchange.sendResponseHeaders(200, bytes.length);
        exchange.getResponseBody().write(bytes);
        // Konsolenprotokoll der Anfragen
        IO.println("%s %s -> %d".formatted(exchange.getRequestMethod(), exchange.getRequestURI(),
                exchange.getResponseCode()));
    }
}

// HTML-Kodierung: die Sonderzeichen und die Nicht-ASCII-Zeichen werden zu Entitäten &#nnn;
String encodeHtml(String text) {
    var result = new StringBuilder();
    text.codePoints().forEach(c -> {
        if (c > 127 || c == '<' || c == '>' || c == '&' || c == '"' || c == '\'') {
            result.append("&#").append(c).append(';');
        } else {
            result.appendCodePoint(c);
        }
    });
    return result.toString();
}

// die Parameter name1=value1&name2=value2 der URL, dekodiert
Map<String, String> parameters(String query) {
    Map<String, String> result = new HashMap<>();
    if (query != null) {
        for (String pair : query.split("&")) {
            String[] fields = pair.split("=", 2);
            result.put(fields[0], fields.length == 2 ? URLDecoder.decode(fields[1], UTF_8) : "");
        }
    }
    return result;
}

Erläuterungen:

  • Zeilen 10–11: Eine Übersetzungsrichtung ist ein Record, bestehend aus einer Bezeichnung und einem Wörterbuch;
  • Zeilen 20–28: die drei angebotenen Übersetzungsrichtungen mit ihren Codes ([fe] für Französisch → Englisch, [ef] für Englisch → Französisch, [fs] für Französisch → Spanisch), ihren Bezeichnungen und ihren Wörterbüchern. [Map.of] akzeptiert höchstens zehn Paare (Name, Wert); für mehr verwendet man [Map.ofEntries];
  • Zeile 31: Die einzige Seite der Website, [/translation], kann zwei Parameter erhalten: die Übersetzungsrichtung [direction] und den Text [text] (Zeilen 39–41);
  • Zeilen 53–54: die Dropdown-Liste. Wie auf Websites dieser Zeit üblich, sind die [<option>]-Tags nicht geschlossen: Der HTML-Code echter Websites ist nicht immer sehr sauber, und unser Client muss damit zurechtkommen;
  • Zeilen 65–67: die Wort-für-Wort-Übersetzung. Der reguläre Ausdruck [\p{L}+'?] (Zeile 16) erfasst ein Wort, also eine Folge von Buchstaben ([\p{L}]), eventuell gefolgt von einem Apostroph ([l'], [d']). Wir haben nicht [\w]verwendet: In Java steht [\w] standardmäßig nur für Buchstaben ohne Akzente, Ziffern und das Zeichen [_], und [été] wäre nicht als Wort erkannt worden. Die Methode [replaceAll] von [Matcher] (Java 9) ersetzt jedes Wort durch das Ergebnis einer Funktion: seine Übersetzung oder das Wort selbst, wenn es unbekannt ist. [Matcher.quoteReplacement] schützt die Zeichen [$] und [\], die in einem Ersetzungstext eine besondere Bedeutung haben;
  • Zeilen 68–69: Die Übersetzung wird in ein [<div class="txtTrans">]-Tag eingeschlossen, wie es auf Websites dieser Zeit üblich war. Sie wird mit der Methode [encodeHtml] kodiert (Zeilen 86–96): Zeichen, die in HTML eine Bedeutung haben ([<], [&] …), und Nicht-ASCII-Zeichen werden durch numerische Entitäten [&#nnn;] ersetzt. Das JDK hat keine Methode zur HTML-Kodierung: Webanwendungen verwenden die ihres Frameworks;
  • Zeile 71: Eine unbekannte Übersetzungsrichtung führt zu einer Seite ohne Übersetzung.

Hier ist die mit [curl] erzeugte Seite für die Übersetzung von [l'été sera chaud] ins Spanische; beachten Sie die Textkodierung in der URL:

> curl -s "http://localhost:27220/translation?direction=fs&text=l%27%C3%A9t%C3%A9%20sera%20chaud"
<!DOCTYPE html>
<html lang="en">
<head><meta charset="utf-8"><title>Translator of the Java course</title></head>
<body>
<h1>Translation of texts</h1>
<form action="/translation" method="get">
<textarea name="text" rows="4" cols="60"></textarea>
<select name="direction">
    <option value='fe'>French to English
    <option value='ef'>English to French
    <option value='fs'>French to Spanish
</select>
<input type="submit" value="Translate">
</form>
<strong>Translated text: </strong><div class="txtTrans">el verano ser&#225; caliente</div>
</body>
</html>

Um den Client zu schreiben, müssen wir:

  • wissen, was die Website erwartet: eine Anfrage [GET /translation?direction=code&text=encoded text]. Bei einer echten Website lässt sich das herausfinden, indem man die vom Browser nach einer Übersetzung angezeigte URL betrachtet oder das Attribut [action] des Formulars;
  • wissen, wo sich in den empfangenen Seiten die benötigten Informationen befinden: Die Übersetzungsrichtungen stehen in den [<option value='code'>label]-Tags der Dropdown-Liste (Zeilen 10–12 der obigen Seite), und die Übersetzung steht im [<div class="txtTrans">]-Tag (Zeile 16). Das lässt sich herausfinden, indem man sich den Quelltext der Seite im Browser ansieht.

Zwei reguläre Ausdrücke (Kapitel 5) können verwendet werden, um diese Informationen zu extrahieren:

  • [<option[^>]*value='(\w+)'>([^<\r\n]+)]: ein [<option]-Tag, gefolgt von anderen Zeichen als [>], [value='], dem Code (erste Gruppe), [>] und dann der Bezeichnung, also den Zeichen, die bis zum nächsten [<] oder bis zum Zeilenende folgen (zweite Gruppe);
  • [<div class="txtTrans">(.*?)</div>]: Die Übersetzung ist der Text (erste Gruppe) zwischen dem öffnenden Tag und dem ersten darauf folgenden [</div>]-Tag. Der Quantifizierer [*?] ist „lazy“: Er nimmt so wenige Zeichen wie möglich.

12.7.3.3. Der Client TranslationService

Der Kürze halber fassen wir die Schnittstelle [ITranslationService], ihre Implementierung [TranslationService], die Exception [TranslationException] und das Testprogramm in einer einzigen kompakten Quelldatei zusammen; in einer echten Anwendung würden die Schnittstelle und ihre Implementierung eine eigene Bibliothek bilden. Das Programm [Internet17.java] sieht wie folgt aus:

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;

import static java.nio.charset.StandardCharsets.UTF_8;

// "Proxy"-Client eines Übersetzungs-Webdienstes: die Klasse TranslationService
// verbirgt vor dem Programm den HTTP-Dialog und das Parsen der HTML-Seiten der Übersetzungsseite
// Aufruf: java Internet17.java [siteUrl]   (standardmäßig http://localhost:27220/)

// ein Übersetzungsversuch
record Trial(String text, String direction) {
}

void main(String[] args) {
    URI siteUrl = URI.create(args.length == 1 ? args[0] : "http://localhost:27220/");
    try (HttpClient client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10)).build()) {
        // Erzeugung des Übersetzungsdienstes: er fragt die Seite ab, um die übersetzten Sprachen zu erfahren
        ITranslationService service = TranslationService.create(client, siteUrl);
        IO.println("Translation directions offered by the site:");
        service.translatedLanguages().forEach((code, label) -> IO.println("  " + code + " : " + label));
        // einige Übersetzungen
        List<Trial> trials = List.of(
                new Trial("ce chien est perdu", "fe"),
                new Trial("l'été sera chaud", "fs"),
                new Trial("my tailor is rich", "ef"),
                new Trial("xx", "ef"),
                new Trial("", "fe"),
                new Trial("hello", "fx"));
        for (Trial trial : trials) {
            try {
                String translation = service.translate(trial.text(), trial.direction());
                IO.println("Translation [%s] of [%s] : [%s]".formatted(
                        service.translatedLanguages().get(trial.direction()), trial.text(), translation));
            } catch (TranslationException e) {
                IO.println("The following error with code " + e.getCode() + " occurred: "
                        + e.getMessage());
            }
        }
    } catch (TranslationException e) {
        IO.println("The following error with code " + e.getCode() + " occurred: " + e.getMessage());
        // die mögliche Ursache: toString liefert ihre Klasse, gefolgt von ihrer Meldung, falls vorhanden
        if (e.getCause() != null) {
            IO.println("Cause: " + e.getCause());
        }
    }
}

// --------------------------------------------------------------------
// die dem Programm angebotene Schnittstelle
interface ITranslationService {

    // die Übersetzungsrichtungen: Code -> Label, zum Beispiel fe -> French to English
    Map<String, String> translatedLanguages();

    // Übersetzung eines Textes in der durch seinen Code angegebenen Richtung
    String translate(String text, String direction);
}

// die für den Übersetzungsdienst spezifische Exception (ungeprüft), mit einem Fehlercode
// static: in einer kompakten Quelldatei wäre eine Klasse ohne static eine innere Klasse
static class TranslationException extends RuntimeException {

    @Serial
    private static final long serialVersionUID = 1L;

    private final int code;

    TranslationException(String message, int code) {
        this(message, null, code);
    }

    TranslationException(String message, Throwable cause, int code) {
        super(message, cause);
        this.code = code;
    }

    int getCode() {
        return code;
    }
}

// die Implementierung: ein HTTP-Client der Übersetzungsseite
static class TranslationService implements ITranslationService {

    // die Optionen <option value='fe'>French to English des Formulars
    private static final Pattern OPTION = Pattern.compile("<option[^>]*value='(\\w+)'>([^<\\r\\n]+)");
    // die Übersetzung: <div class="txtTrans">...</div>
    private static final Pattern TRANSLATION = Pattern.compile("<div class=\"txtTrans\">(.*?)</div>");
    // eine HTML-Entität: &#225; oder &ccedil;
    private static final Pattern ENTITY = Pattern.compile("&(#\\d+|\\w+);");
    // die wenigen benannten Entitäten, die dekodiert werden können
    private static final Map<String, String> ENTITIES = Map.of(
            "amp", "&", "lt", "<", "gt", ">", "quot", "\"", "apos", "'", "ccedil", "ç", "eacute", "é");

    // der HTTP-Client und die Adresse der Seite, vom Programm bereitgestellt
    private final HttpClient client;
    private final URI siteUrl;
    private final Map<String, String> translatedLanguages;

    // privater Konstruktor: es wird die Factory-Methode create verwendet
    private TranslationService(HttpClient client, URI siteUrl, Map<String, String> languages) {
        this.client = client;
        this.siteUrl = siteUrl;
        this.translatedLanguages = languages;
    }

    @Override
    public Map<String, String> translatedLanguages() {
        return translatedLanguages;
    }

    // Erzeugung des Dienstes: die Übersetzungsrichtungen werden aus dem Formular der Seite gelesen
    static TranslationService create(HttpClient client, URI siteUrl) {
        String page;
        try {
            HttpRequest request = HttpRequest.newBuilder(siteUrl.resolve("translation"))
                    .timeout(Duration.ofSeconds(10)).build();
            page = client.send(request, BodyHandlers.ofString()).body();
        } catch (IOException | InterruptedException e) {
            throw new TranslationException("The translation site is unreachable", e, 11);
        }
        Map<String, String> languages = new LinkedHashMap<>();
        Matcher option = OPTION.matcher(page);
        while (option.find()) {
            // die HTML-Entitäten (&ccedil;...) werden dekodiert
            languages.put(option.group(1), decodeHtml(option.group(2).strip()));
        }
        if (languages.isEmpty()) {
            throw new TranslationException("The site gives no translation direction", 13);
        }
        return new TranslationService(client, siteUrl, Collections.unmodifiableMap(languages));
    }

    // Übersetzung
    @Override
    public String translate(String text, String direction) {
        // ist die angeforderte Übersetzung möglich?
        if (!translatedLanguages.containsKey(direction)) {
            throw new TranslationException("The translation direction [" + direction + "] is not recognized", 10);
        }
        // die anzufordernde URL: der Text muss kodiert werden
        URI url = siteUrl.resolve("translation?direction=" + direction + "&text=" + URLEncoder.encode(text, UTF_8));
        HttpRequest request = HttpRequest.newBuilder(url).timeout(Duration.ofSeconds(10)).build();
        Optional<String> translation;
        try {
            // das Dokument wird als Stream von Zeilen zurückgegeben, beim Eintreffen gelesen
            HttpResponse<Stream<String>> response = client.send(request, BodyHandlers.ofLines());
            if (response.statusCode() != 200) {
                throw new TranslationException("The site responded with code " + response.statusCode(), 11);
            }
            // die Übersetzung wird Zeile für Zeile gesucht, und wir hören auf, sobald sie gefunden ist
            try (Stream<String> lines = response.body()) {
                translation = lines.map(TRANSLATION::matcher)
                        .filter(Matcher::find)
                        .map(result -> decodeHtml(result.group(1).strip()))
                        .findFirst();
            }
        } catch (IOException | UncheckedIOException | InterruptedException e) {
            throw new TranslationException("Error encountered during the translation", e, 11);
        }
        // die Seite enthielt keine Übersetzung
        return translation.orElseThrow(
                () -> new TranslationException("The server did not send back a translation", 12));
    }

    // Dekodierung der HTML-Entitäten eines Textes
    private static String decodeHtml(String text) {
        return ENTITY.matcher(text).replaceAll(entity -> {
            String name = entity.group(1);
            String character = name.startsWith("#")
                    ? Character.toString(Integer.parseInt(name.substring(1)))
                    : ENTITIES.getOrDefault(name, entity.group());
            return Matcher.quoteReplacement(character);
        });
    }
}

Beginnen wir mit der Schnittstelle und der Exception:

  • Zeilen 52–59: die dem Programm angebotene Schnittstelle. Die Methode [translatedLanguages] liefert das Wörterbuch der von der Website akzeptierten Übersetzungsrichtungen, bestehend aus Einträgen der Form [fe] → [French to English]; die Methode [translate] übersetzt den Text [text] in die Richtung mit dem Code [direction]. Sie ist synchron: Ein Programm, das mehrere Übersetzungen parallel ausführen möchte, führt sie in virtuellen Threads aus;
  • Zeilen 63–82: die dienstspezifische ungeprüfte Exception mit einem Fehlercode, nach dem Vorbild von [TaxException] (Kapitel 6). In einer kompakten Quelldatei sind alle Deklarationen Member der impliziten Klasse: Eine ohne das Schlüsselwort [static] deklarierte Klasse wäre eine innere Klasse, deren Instanzen nur aus einer Instanz der impliziten Klasse heraus erzeugt werden können. Schnittstellen und Records hingegen sind immer implizit statisch;
  • Zeilen 65–66: Eine Exception ist serialisierbar; [-Xlint:all] verlangt daher eine Versionsnummer, annotiert als [@Serial] (Java 14).

Die Klasse [TranslationService]:

  • Zeilen 88–95: die oben vorgestellten regulären Ausdrücke, einmalig kompiliert, und ein dritter für HTML-Entitäten, die numerisch ([&#225;]) oder benannt ([&ccedil;]) sein können;
  • Zeile 98: Der Service erzeugt seinen [HttpClient] nicht selbst; er erhält ihn vom Programm, das Konfiguration und Lebensdauer festlegt;
  • Zeile 103: Der Konstruktor ist privat. Der Service kann erst nach einer Abfrage der Website erzeugt werden; anstatt diese Netzwerkoperation in einem Konstruktor auszuführen, verwenden wir eine statische Erzeugungsmethode, [create];
  • Zeilen 115–134: Erzeugung des Services. Die Liste der Übersetzungsrichtungen wird direkt von der Website selbst gelesen, was dafür sorgt, dass sie aktuell ist:
    • Zeilen 118–120: Die Formularseite wird ohne Parameter abgefragt;
    • Zeilen 121–123: Ein Kommunikationsfehler wird in eine [TranslationException] mit dem Code 11 eingekapselt;
    • Zeilen 125–129: Jedes vom regulären Ausdruck gefundene [<option>]-Tag liefert einen Code (Gruppe 1) und eine Bezeichnung (Gruppe 2). Die Methode [decodeHtml] (Zeilen 169–177) ersetzt die HTML-Entitäten durch die Zeichen, die sie darstellen: Die Bezeichnungen der Website enthalten keine, aber [Fran&ccedil;ais] würde zu [Français];
    • Zeile 133: Das Wörterbuch wird durch [Collections.unmodifiableMap] unveränderbar gemacht, was die Reihenfolge von [LinkedHashMap] beibehält;
  • Zeilen 138–166: die Übersetzung:
    • Zeilen 140–142: Es wird geprüft, ob die verlangte Übersetzungsrichtung existiert;
    • Zeile 144: Die URL der Anfrage wird erstellt, wobei der Text kodiert wird;
    • Zeile 149: Der Handler [BodyHandlers.ofLines()] liefert die Antwort, sobald deren Header eintreffen; ihr Dokument ist ein Stream ([Stream<String>]) von Zeilen, die beim Eintreffen gelesen werden;
    • Zeilen 154–159: Die Übersetzung wird Zeile für Zeile gesucht, und die Suche endet beim ersten gefundenen Treffer: [findFirst] unterbricht den Stream, und der Rest der Seite wird nie gelesen. Der Stream wird beim Verlassen des [try] -with-resources geschlossen, wodurch die Verbindung freigegeben wird. Das Ergebnis ist ein [Optional<String>], das leer ist, wenn keine Zeile eine Übersetzung enthält;
    • Zeilen 160–162: Ein Kommunikationsfehler führt zu einer Exception mit Code 11. Ein Fehler beim Lesen des Zeilen-Streams wird durch eine [UncheckedIOException] signalisiert, da die Methoden von [Stream] keine geprüfte Exception auslösen können;
    • Zeilen 164–165: Wurde die Seite vollständig gelesen, ohne eine Übersetzung zu finden, wird eine Exception mit Code 12 ausgelöst.

Das Testprogramm:

  • Zeile 17: Die Adresse der Website kann als Argument übergeben werden;
  • Zeile 18: der HTTP-Client der Anwendung;
  • Zeile 20: Erzeugung des Services. Das Programm interagiert danach nur noch über seine Schnittstelle [ITranslationService] mit dem Service;
  • Zeilen 24–30: einige Testläufe, darunter zwei Fehlerfälle: eine leere Zeichenkette als Text und eine unbekannte Übersetzungsrichtung. Jeder Testlauf ist ein [Trial]-Record (Zeilen 13–14).

Ergebnisse, wobei die Website [Internet16.java] in einem anderen Fenster gestartet wurde:

> java Internet17.java
Translation directions offered by the site:
  fe : French to English
  ef : English to French
  fs : French to Spanish
Translation [French to English] of [ce chien est perdu] : [this dog is lost]
Translation [French to Spanish] of [l'été sera chaud] : [el verano será caliente]
Translation [English to French] of [my tailor is rich] : [mon tailleur est riche]
Translation [English to French] of [xx] : [xx]
The following error with code 12 occurred: The server did not send back a translation
The following error with code 10 occurred: The translation direction [fx] is not recognized
  • Zeilen 3–5: Die Übersetzungsrichtungen wurden aus dem Formular der Website gelesen;
  • Zeile 9: Ein unbekanntes Wort wird unverändert wiedergegeben;
  • Zeile 10: Bei einem leeren Text lieferte die Website ihr Formular ohne Übersetzung zurück;
  • Zeile 11: Die Übersetzung [fx] wurde vom Service abgelehnt, ohne die Website abzufragen.

Wenn die Website nicht verfügbar ist:

1
2
3
> java Internet17.java http://localhost:27299/
The following error with code 11 occurred: The translation site is unreachable
Cause: java.net.ConnectException

Auf Seiten der Website finden wir die oben gesehene Anfrage von [curl] , gefolgt von denen des Clients: die erste für das Formular, die folgenden für die Übersetzungen (die vom Service abgelehnte Übersetzung [fx] führte zu keiner Anfrage). [URLEncoder] kodierte die Leerzeichen mit [+], während die URL, die an [curl] übergeben wurde, sie mit [%20] kodierte:

1
2
3
4
5
6
7
8
9
> java Internet16.java
Translation service started on http://localhost:27220/translation
GET /translation?direction=fs&text=l%27%C3%A9t%C3%A9%20sera%20chaud -> 200
GET /translation -> 200
GET /translation?direction=fe&text=ce+chien+est+perdu -> 200
GET /translation?direction=fs&text=l%27%C3%A9t%C3%A9+sera+chaud -> 200
GET /translation?direction=ef&text=my+tailor+is+rich -> 200
GET /translation?direction=ef&text=xx -> 200
GET /translation?direction=fe&text= -> 200

12.7.3.4. Fazit

Diese Anwendung hat gezeigt, dass [HttpClient] es uns erlaubt, Webressourcen zu nutzen. Die Technik ist jedes Mal dieselbe:

  • die abzufragende URL bestimmen. Sie ist in der Regel vorkonfiguriert;
  • sie abfragen;
  • mithilfe regulärer Ausdrücke in der Antwort des Servers finden, was wir suchen.

Diese Technik, heute als „Web Scraping“ bekannt, ist fragil: Mit der Zeit können sich die abgefragte URL oder die Struktur der Seite ändern, und der reguläre Ausdruck, der das Ergebnis früher fand, funktioniert möglicherweise nicht mehr. Es empfiehlt sich, diese Informationen in einer Konfigurationsdatei abzulegen, doch das reicht nicht immer aus; außerdem untersagen die Nutzungsbedingungen vieler Websites dieses Vorgehen. Eine robuste Analyse einer HTML-Seite ließe sich tatsächlich besser mit einer spezialisierten Bibliothek wie jsoup durchführen als mit regulären Ausdrücken. Im nächsten Kapitel werden wir sehen, dass es im Web stabilere Ressourcen gibt, die für die Nutzung durch Programme entworfen wurden: Webservices. Aktuelle Übersetzungsdienste bieten zum Beispiel alle eine Schnittstelle dieser Art an, die JSON akzeptiert und zurückgibt.

12.7.4. Ein SMTP-Client mit Jakarta Mail

Ein SMTP-Client ist ein Client eines SMTP-Servers, also eines Servers zum Versenden von E-Mails, dessen Protokoll wir in Teil 1 beschrieben haben. Das JDK hat keine Klasse für E-Mail. Die De-facto-Standardbibliothek ist Jakarta Mail (früher JavaMail), deren Referenzimplementierung heute Eclipse Angus Mail heißt. Sie kapselt die Anforderungen eines E-Mail-Clients: Der Entwickler muss weder die Einzelheiten des SMTP-Protokolls noch die des MIME-Nachrichtenformats kennen. Ihre wichtigsten Klassen sind [Session] (die Konfiguration), [MimeMessage] (eine Nachricht), [InternetAddress] (eine E-Mail-Adresse), [MimeMultipart] und [MimeBodyPart] (eine mehrteilige Nachricht, etwa aus Text und Anhängen) sowie [Transport], die die Nachricht versendet. Sie kann auch E-Mails über POP3 und IMAP lesen und übernimmt die Authentifizierung und Verschlüsselung (TLS), die echte Server verlangen.

Wir können keine E-Mail an einen echten SMTP-Server senden: Unser Testrechner hat keinen Internetzugang, und, wie erwähnt, sperren Internetanbieter Port 25. Die E-Mail wird an einen kleinen Testserver gesendet, der in Java geschrieben ist und auf dem lokalen Rechner läuft; er zeigt alles an, was er empfängt, und leitet nichts weiter. Für den praktischen Einsatz gibt es voll ausgestattete Testserver wie Mailpit oder GreenMail (in Java geschrieben), die zudem eine Oberfläche zum Ansehen der empfangenen Nachrichten bieten.

12.7.4.1. Ein SMTP-Testserver

Unser SMTP-Server folgt der Struktur des Echo-Servers aus Teil 1: eine Schleife, die auf Clients wartet, ein virtueller Thread pro Client und sauberes Beenden per Strg-C. Der jedem Client angebotene Dienst ist der minimale SMTP-Dialog aus Teil 1. Das Programm [Internet18.java] sieht wie folgt aus:

import static java.nio.charset.StandardCharsets.UTF_8;

// SMTP-Testserver: er spielt den minimalen SMTP-Dialog und zeigt die empfangenen Nachrichten an,
// ohne sie je an ihre Empfänger zuzustellen
// Aufruf: java Internet18.java [port]   (standardmäßig Port 27225); Stopp mit Ctrl-C

final Set<Socket> connections = ConcurrentHashMap.newKeySet();
volatile boolean stop = false;

void main(String[] args) {
    int port = args.length == 1 ? Integer.parseInt(args[0]) : 27225;
    // der Server akzeptiert nur die Clients des lokalen Rechners (Loopback-Adresse)
    try (var listener = new ServerSocket(port, 50, InetAddress.getLoopbackAddress());
         var services = Executors.newVirtualThreadPerTaskExecutor()) {
        stopOnCtrlC(listener);
        IO.println("Test SMTP server started on " + listener.getLocalSocketAddress());
        try {
            for (int clientNum = 0; ; clientNum++) {
                Socket client = listener.accept();
                connections.add(client);
                int number = clientNum;
                services.submit(() -> serve(client, number));
            }
        } catch (SocketException e) {
            if (!stop) {
                throw e;
            }
            IO.println("Server stop requested");
            for (Socket connection : connections) {
                connection.close();
            }
        }
    } catch (IOException e) {
        IO.println("The following error occurred on the server: " + e.getMessage());
    }
}

// Ctrl-C: Schließen des lauschenden Dienstes, dann Warten auf das Ende des Hauptprogramms
void stopOnCtrlC(ServerSocket listener) {
    Thread main = Thread.currentThread();
    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
        stop = true;
        try {
            listener.close();
            main.join();
        } catch (IOException | InterruptedException e) {
            // wir stoppen trotzdem
        }
    }));
}

// der SMTP-Dialog mit einem Client: C: vom Client empfangene Zeilen, S: vom Server gesendete Zeilen
void serve(Socket client, int clientNum) {
    IO.println("--- start of the dialog with client " + clientNum + " ("
            + client.getRemoteSocketAddress() + ")");
    try (client;
         var reader = new BufferedReader(new InputStreamReader(client.getInputStream(), UTF_8));
         var writer = new OutputStreamWriter(client.getOutputStream(), UTF_8)) {
        // Senden einer Antwortzeile, auch auf der Konsole angezeigt; SMTP verlangt das Zeilenende \r\n
        Responder reply = response -> {
            IO.println("S: " + response);
            writer.write(response + "\r\n");
            writer.flush();
        };
        // der Umschlag der aktuellen Nachricht: Absender und Empfänger
        String sender = null;
        List<String> recipients = new ArrayList<>();
        // Willkommensnachricht
        reply.send("220 smtp.test ESMTP test server of the Java course");
        String command;
        while ((command = reader.readLine()) != null) {
            IO.println("C: " + command);
            // das Verb: die ersten vier Zeichen, unabhängig von der Groß-/Kleinschreibung
            String verb = command.length() >= 4 ? command.substring(0, 4) : command;
            verb = verb.toUpperCase(Locale.ROOT);
            // was auf das Zeichen ":" in MAIL FROM:<address> und RCPT TO:<address> folgt
            String address = command.substring(command.indexOf(':') + 1).strip();
            switch (verb) {
                case "EHLO" -> {
                    // Antwort über mehrere Zeilen: 250-... dann 250 ...
                    reply.send("250-smtp.test hello");
                    reply.send("250-SIZE 10485760");
                    reply.send("250 8BITMIME");
                }
                case "HELO" -> reply.send("250 smtp.test hello");
                case "MAIL" -> {
                    sender = address;
                    recipients.clear();
                    reply.send("250 2.1.0 Ok");
                }
                case "RCPT" -> {
                    recipients.add(address);
                    reply.send("250 2.1.5 Ok");
                }
                case "DATA" -> {
                    // zuerst werden der Absender und die Empfänger benötigt
                    if (sender == null || recipients.isEmpty()) {
                        reply.send("503 5.5.1 Give the sender and the recipients first");
                        continue;
                    }
                    reply.send("354 End data with <CR><LF>.<CR><LF>");
                    // die Nachricht: alle Zeilen bis zu einer Zeile, die nur aus einem Punkt besteht
                    int nbLines = 0;
                    String line;
                    while ((line = reader.readLine()) != null && !line.equals(".")) {
                        IO.println("C: " + line);
                        nbLines++;
                    }
                    // der Client hat die Verbindung vor dem Ende der Nachricht geschlossen
                    if (line == null) {
                        IO.println("[incomplete message: connection closed by the client]");
                        return;
                    }
                    IO.println("C: .");
                    IO.println("[message from %s to %s: %d lines]".formatted(sender,
                            String.join(", ", recipients), nbLines));
                    reply.send("250 2.0.0 Ok: message accepted");
                    sender = null;
                    recipients.clear();
                }
                case "RSET" -> {
                    sender = null;
                    recipients.clear();
                    reply.send("250 2.0.0 Ok");
                }
                case "NOOP" -> reply.send("250 2.0.0 Ok");
                case "QUIT" -> {
                    reply.send("221 2.0.0 Bye");
                    return;
                }
                default -> reply.send("502 5.5.2 Command not recognized");
            }
        }
    } catch (IOException e) {
        if (stop) {
            IO.println("Dialog with client " + clientNum + " interrupted by the server stop");
        } else {
            IO.println("The following error occurred with client " + clientNum + ": "
                    + e.getMessage());
        }
    } finally {
        connections.remove(client);
        IO.println("--- end of the dialog with client " + clientNum);
    }
}

// Senden einer Antwortzeile: ein funktionales Interface, dessen Methode eine IOException werfen kann
interface Responder {
    void send(String response) throws IOException;
}

Wir kommentieren nur, was im Vergleich zum Echo-Server neu ist:

  • Zeile 13: Der Server lauscht nur auf der Loopback-Adresse; nur Programme auf demselben Rechner können sich mit ihm verbinden. Der zweite Parameter (50) ist die Größe der Warteschlange für Verbindungen;
  • Zeilen 60–64: ein Lambda, das eine Antwortzeile an den Client sendet, mit \r\n abgeschlossen, wie es SMTP verlangt, und sie auf der Konsole anzeigt, mit dem Präfix [S:]. Vom Client empfangene Zeilen werden mit dem Präfix [C:] angezeigt, wie in den Beispieldialogen aus Teil 1. Die funktionalen Schnittstellen des JDK ([Consumer<String>] …) erlauben keine geprüften Exceptions: Daher deklarieren wir unsere eigene funktionale Schnittstelle, [Responder] (Zeilen 148–150), deren Methode eine [IOException] auslösen darf;
  • Zeilen 66–67: der Umschlag der aktuellen Nachricht: der durch [MAIL FROM] angegebene Absender und die durch [RCPT TO] angegebenen Empfänger;
  • Zeile 69: die Begrüßungsnachricht: Bei SMTP spricht der Server zuerst;
  • Zeilen 74–75: Das Befehlswort besteht aus den ersten vier Zeichen des Befehls ([EHLO], [MAIL], [RCPT] …) in Großbuchstaben. [Locale.ROOT] macht die Umwandlung unabhängig von der Sprache des Rechners (im Türkischen ist der Großbuchstabe von [i] nicht [I]);
  • Zeilen 79–84: Die Antwort auf [EHLO] besteht aus mehreren Zeilen. Der Server listet hier seine Fähigkeiten auf: die maximale Nachrichtengröße ([SIZE]) und die Unterstützung von 8-Bit-kodierten Zeichen ([8BITMIME]);
  • Zeilen 97–100: Der Befehl [DATA] wird abgelehnt, wenn Absender oder Empfänger nicht angegeben wurden; [continue] springt zum nächsten Befehl;
  • Zeilen 101–119: die Nachricht selbst. Der Server fordert den Client auf, sie zu senden (Code 354), liest und zeigt dann alle Zeilen bis zu einer Zeile an, die nur aus einem einzelnen Punkt besteht, und bestätigt den Empfang (Code 250). Schließt der Client die Verbindung vor dem Ende der Nachricht, wird die Nachricht verworfen (Zeilen 110–113);
  • Zeilen 127–130: Der Client ist fertig; der Server antwortet und schließt die Verbindung, indem er die Methode verlässt (das [try] with resources schließt den Socket);
  • Zeile 131: Jeder andere Befehl wird abgelehnt.

Dieser Server führt nur wenige Prüfungen durch und unterstützt die Erweiterungen [STARTTLS] und [AUTH] nicht: Er genügt, um zu beobachten, was Jakarta Mail sendet.

12.7.4.2. Der SMTP-Client

Das Programm [Internet19] fragt den Benutzer nach den Angaben zur E-Mail (Absender, Empfänger, Betreff, Anhänge, Text) und sendet sie dann an den als Argument angegebenen SMTP-Server. Es handelt sich um ein Maven-Projekt, in dem [pom.xml] die folgende Abhängigkeit deklariert:

1
2
3
4
5
6
7
8
    <dependencies>
        <!-- Jakarta Mail: die API jakarta.mail und ihre Implementierung Eclipse Angus -->
        <dependency>
            <groupId>org.eclipse.angus</groupId>
            <artifactId>angus-mail</artifactId>
            <version>2.0.3</version>
        </dependency>
    </dependencies>

Die Abhängigkeit [angus-mail] stellt die Implementierung und, über transitive Abhängigkeiten, die von ihr verwendeten Bibliotheken der API, [jakarta.mail], und [jakarta.activation], bereit. Der Code verwendet nur die API in den Paketen [jakarta.mail] und [jakarta.mail.internet]. Die Klasse [Internet19] sieht wie folgt aus:

package internet;

import jakarta.mail.Message.RecipientType;
import jakarta.mail.MessagingException;
import jakarta.mail.Session;
import jakarta.mail.Transport;
import jakarta.mail.internet.AddressException;
import jakarta.mail.internet.InternetAddress;
import jakarta.mail.internet.MimeBodyPart;
import jakarta.mail.internet.MimeMessage;
import jakarta.mail.internet.MimeMultipart;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

// Senden einer E-Mail mit Jakarta Mail
// Aufruf: mvn exec:java -Dexec.args="smtpServer port"
// die Anhänge werden im aktuellen Ordner gesucht
public class Internet19 {

    private static final String SYNTAX = "Syntax: mvn exec:java -Dexec.args=\"smtpServer port\"";

    public static void main(String[] args) {
        if (args.length != 2 || !args[1].matches("\\d{1,5}")) {
            IO.println(SYNTAX);
            return;
        }
        String server = args[0];
        String port = args[1];

        // Eingabe der Elemente der Mail
        String sender = input("Sender");
        String recipients = input("Recipients (separated by commas)");
        String copies = input("Copy to (Cc)");
        String blindCopies = input("Blind copy to (Bcc)");
        String subject = input("Subject");
        String attachments = input("Attachments (separated by commas)");
        // der Text: mehrere Zeilen, durch eine Leerzeile beendet
        IO.println("Text of the message (ended by an empty line):");
        var text = new StringBuilder();
        String line;
        while ((line = IO.readln()) != null && !line.isEmpty()) {
            text.append(line).append('\n');
        }

        try {
            // die Mail-Session: sie enthält die Konfiguration des SMTP-Clients
            var properties = new Properties();
            properties.put("mail.smtp.host", server);
            properties.put("mail.smtp.port", port);
            Session session = Session.getInstance(properties);

            // die Nachricht
            var message = new MimeMessage(session);
            var from = new InternetAddress(sender, true);
            from.validate();
            message.setFrom(from);
            message.setRecipients(RecipientType.TO, addresses(recipients));
            message.setRecipients(RecipientType.CC, addresses(copies));
            message.setRecipients(RecipientType.BCC, addresses(blindCopies));
            message.setSubject(subject, "UTF-8");
            // eine mehrteilige Nachricht: zuerst der Text, in UTF-8 unverändert übertragen (8 Bit)
            var textPart = new MimeBodyPart();
            textPart.setText(text.toString(), "UTF-8");
            textPart.setHeader("Content-Transfer-Encoding", "8bit");
            var content = new MimeMultipart(textPart);
            // dann die Anhänge, durch ihren Pfad bezeichnet
            List<String> names = new ArrayList<>();
            for (String file : attachments.split(",")) {
                if (!file.isBlank()) {
                    var part = new MimeBodyPart();
                    part.attachFile(new File(file.strip()));
                    content.addBodyPart(part);
                    names.add(part.getFileName());
                }
            }
            message.setContent(content);

            // das Senden: Transport kennt das SMTP-Protokoll; die Nachricht kennt das MIME-Format
            Transport.send(message);

            // Zusammenfassung des Sendevorgangs
            IO.println("Sending successful...");
            IO.println("Subject: " + message.getSubject());
            IO.println("Recipients: " + list(message, RecipientType.TO));
            IO.println("Cc: " + list(message, RecipientType.CC));
            IO.println("Bcc: " + list(message, RecipientType.BCC));
            IO.println("Attachments: " + String.join(", ", names));
        } catch (MessagingException | IOException e) {
            IO.println("The following error occurred: " + e.getClass().getSimpleName() + " : "
                    + e.getMessage());
            if (e.getCause() != null) {
                IO.println("Cause: " + e.getCause());
            }
        }
    }

    // eine Liste von durch Kommas getrennten Adressen; jede Adresse wird geprüft
    private static InternetAddress[] addresses(String list) throws AddressException {
        InternetAddress[] addresses = InternetAddress.parse(list, true);
        for (InternetAddress address : addresses) {
            address.validate();
        }
        return addresses;
    }

    // die Adressen einer Empfängerkategorie, durch Kommas getrennt
    private static String list(MimeMessage message, RecipientType type) throws MessagingException {
        return InternetAddress.toString(message.getRecipients(type));
    }

    // Eingabe einer Zeile über die Tastatur
    private static String input(String label) {
        String line = IO.readln(label + " : ");
        return line == null ? "" : line.strip();
    }
}

Erläuterungen:

  • Zeilen 34–46: Eingabe der E-Mail-Elemente mit der Methode [input] (Zeilen 115–118). Der Nachrichtentext besteht aus mehreren Zeilen und endet mit einer Leerzeile;
  • Zeilen 50–53: die E-Mail-Sitzung. Ihre Konfiguration ist ein [Properties]-Objekt: hier der Rechner und der Port des SMTP-Servers. Für einen echten Server würden wir [mail.smtp.auth=true], [mail.smtp.starttls.enable=true] (Verschlüsselung über [STARTTLS]) hinzufügen und Benutzername und Passwort an [Transport.send] übergeben;
  • Zeilen 56–63: die Nachricht:
    • Zeilen 57–59: der Absender, ein Objekt vom Typ [InternetAddress]. Der zweite Parameter des Konstruktors ([true]) verlangt eine strikte Validierung der Adresse, und [validate] prüft zusätzlich, ob sie die Form [name@domain] hat; eine fehlerhafte Adresse führt zu einer [AddressException];
    • Zeilen 60–62: die Empfänger, die im Feld „Cc“ (Carbon Copy) und die im Feld „Bcc“ (Blind Carbon Copy). Empfänger im Feld „Bcc“ erhalten die Nachricht, die übrigen Empfänger wissen davon jedoch nichts. Die Methode [addresses] (Zeilen 101–107) zerlegt eine durch Kommas getrennte Adressliste mit [InternetAddress.parse] und validiert jede einzelne;
    • Zeile 63: der Betreff samt seinem Zeichensatz;
  • Zeilen 65–68: Die Nachricht besteht aus mehreren Teilen ([MimeMultipart]). Der erste Teil ist der Text, in UTF-8. Der Header [Content-Transfer-Encoding: 8bit] legt fest, dass er unverändert im 8-Bit-Format übertragen werden soll (der Server hat angezeigt, dass er dies akzeptiert); ohne ihn würde Jakarta Mail eine eigene Kodierung wählen (Quoted-Printable oder Base64), wodurch der Text bei der Anzeige durch den Server schwer lesbar wäre;
  • Zeilen 71–78: die Anhänge, identifiziert durch ihre Dateipfade. Ein relativer Pfad bezieht sich auf das aktuelle Verzeichnis; in unseren Tests befindet sich die Datei [attachment.txt] im Verzeichnis [Internet19], aus dem das Programm gestartet wird. [attachFile] erzeugt einen Teil, dessen Inhalt zum Zeitpunkt des Versands aus der Datei gelesen wird;
  • Zeile 82: Versand der Nachricht mit der statischen Methode [Transport.send], die sich mit dem von der Sitzung angegebenen Server verbindet, den SMTP-Dialog ausführt und die Nachricht im MIME-Format überträgt;
  • Zeilen 85–90: eine Zusammenfassung der Übertragung. [InternetAddress.toString] (Zeile 111) fügt eine Liste von Adressen zu einer einzigen Zeichenkette zusammen;
  • Zeilen 91–97: Eine ungültige Adresse löst eine [AddressException] aus; ein Sendefehler löst eine [MessagingException] aus, deren Ursache angezeigt wird. Ein fehlender Anhang wird erst beim Senden erkannt: Er löst eine [MessagingException] aus, deren Ursache eine [FileNotFoundException] ist.

Der SMTP-Testserver wird in einem Befehlsfenster auf Port 27225 gestartet. In einem anderen Fenster wird aus dem Ordner [Internet19] eine Nachricht an zwei Empfänger gesendet, mit einem Empfänger in Kopie, einem in Blindkopie und einem Anhang:

> mvn compile exec:java -Dexec.args="localhost 27225"
Sender : alice@example.org
Recipients (separated by commas) : bob@example.com, carole@example.com
Copy to (Cc) : david@example.com
Blind copy to (Bcc) : eve@example.com
Subject : Meeting minutes
Attachments (separated by commas) : attachment.txt
Text of the message (ended by an empty line):
Hello,
here are the minutes of the summer meeting.
Best regards,
Alice

Sending successful...
Subject: Meeting minutes
Recipients: bob@example.com, carole@example.com
Cc: david@example.com
Bcc: eve@example.com
Attachments: attachment.txt

Die Datei [attachment.txt] enthält zwei Textzeilen. Das hat der Server angezeigt:

> java Internet18.java
Test SMTP server started on localhost/127.0.0.1:27225
--- start of the dialog with client 0 (/127.0.0.1:47628)
S: 220 smtp.test ESMTP test server of the Java course
C: EHLO localhost
S: 250-smtp.test hello
S: 250-SIZE 10485760
S: 250 8BITMIME
C: MAIL FROM:<alice@example.org>
S: 250 2.1.0 Ok
C: RCPT TO:<bob@example.com>
S: 250 2.1.5 Ok
C: RCPT TO:<carole@example.com>
S: 250 2.1.5 Ok
C: RCPT TO:<david@example.com>
S: 250 2.1.5 Ok
C: RCPT TO:<eve@example.com>
S: 250 2.1.5 Ok
C: DATA
S: 354 End data with <CR><LF>.<CR><LF>
C: Date: Sat, 3 Oct 2026 19:41:44 +0200 (CEST)
C: From: alice@example.org
C: To: bob@example.com, carole@example.com
C: Cc: david@example.com
C: Message-ID: <1094834071.1.1791049304833@localhost>
C: Subject: Meeting minutes
C: MIME-Version: 1.0
C: Content-Type: multipart/mixed; 
C:     boundary="----=_Part_0_1213415012.1791049304796"
C: 
C: ------=_Part_0_1213415012.1791049304796
C: Content-Type: text/plain; charset=UTF-8
C: Content-Transfer-Encoding: 8bit
C: 
C: Hello,
C: here are the minutes of the summer meeting.
C: Best regards,
C: Alice
C: 
C: ------=_Part_0_1213415012.1791049304796
C: Content-Type: text/plain; charset=us-ascii; name=attachment.txt
C: Content-Transfer-Encoding: 7bit
C: Content-Disposition: attachment; filename=attachment.txt
C: 
C: This is the attachment of the test mail.
C: It contains two lines.
C: 
C: ------=_Part_0_1213415012.1791049304796--
C: .
[message from <alice@example.org> to <bob@example.com>, <carole@example.com>, <david@example.com>, <eve@example.com>: 28 lines]
S: 250 2.0.0 Ok: message accepted
C: QUIT
S: 221 2.0.0 Bye
--- end of the dialog with client 0
Server stop requested

Erläuterungen:

  • Zeile 5: Jakarta Mail identifiziert sich mit dem Namen des lokalen Rechners, hier [localhost];
  • Zeilen 9–18: der Nachrichtenumschlag: der Absender, gefolgt von allen Empfängern, einschließlich des Empfängers in Blindkopie ([eve@example.com]). Der Umschlag bestimmt, an wen die Nachricht zugestellt wird;
  • Zeilen 21–29: die Nachrichten-Header, die das ausmachen, was die Empfänger sehen: das Datum, der Absender, die Empfänger [To] und [Cc], eine eindeutige Nachrichtenkennung ([Message-ID]), der Betreff … Der Empfänger in Blindkopie ist hier nicht aufgeführt: So bleibt er verborgen. Die Betreffzeile enthält nur ASCII-Zeichen und wird unverändert gesendet; da Header nur ASCII-Zeichen enthalten können, wäre ein Betreff mit einem akzentuierten Zeichen nach RFC 2047 kodiert worden: [=?UTF-8?Q?...?=] bedeutet „Text in UTF-8, als Quoted-Printable kodiert“, wobei jedes Nicht-ASCII-Byte hexadezimal als [=XX] geschrieben wird ([=C3=A9] für die zwei Bytes von [é]) und jedes Leerzeichen als [_];
  • Zeilen 28–29: Die Nachricht liegt im MIME-Format vor (Multipurpose Internet Mail Extensions, RFC 2045 ff.): Sie besteht aus mehreren Teilen ([multipart/mixed]), die durch eine von Jakarta Mail zufällig gewählte Trennzeile ([boundary]) getrennt sind. Ein zu langer Header darf in der nächsten Zeile fortgesetzt werden, sofern diese mit einem Leerzeichen oder einem Tabulator beginnt;
  • Zeilen 31–39: der erste Teil, der Nachrichtentext, in 8-Bit-UTF-8: Er ist unverändert lesbar;
  • Zeilen 40–47: der zweite Teil, der Anhang. Jakarta Mail hat eine Textdatei ([text/plain]) erkannt, die nur ASCII-Zeichen enthält ([charset=us-ascii]), und sie unverändert übertragen ([7bit]); ein Text mit anderen Zeichen wäre als Quoted-Printable kodiert worden: Diese Kodierung lässt die ASCII-Zeichen lesbar und kodiert die übrigen, etwa [è] ([=C3=A8]). Eine Binärdatei (zum Beispiel ein Bild) wäre in Base64 kodiert worden, das beliebige Bytes mit 64 Zeichen des ASCII-Zeichensatzes darstellt. Der Header [Content-Disposition: attachment] zeigt an, dass es sich um einen Anhang handelt, und gibt seinen Namen an;
  • Zeilen 48–49: die abschließende Trennzeile, gefolgt von zwei Bindestrichen, dann die Zeile, die nur aus einem Punkt besteht und die Nachricht beendet;
  • Zeile 50: Unser Server hat eine Nachricht für vier Empfänger erhalten;
  • Zeilen 52–53: Jakarta Mail beendet die Sitzung;
  • Zeile 55: Der Server wurde nach den Tests mit Strg-C gestoppt.

Eine ungültige Adresse wird abgelehnt, bevor eine Nachricht gesendet wird:

> mvn compile exec:java -Dexec.args="localhost 27225"
Sender : alice@example.org
Recipients (separated by commas) : bob.example.com
Copy to (Cc) : 
Blind copy to (Bcc) : 
Subject : test
Attachments (separated by commas) : 
Text of the message (ended by an empty line):
text

The following error occurred: AddressException : Missing final '@domain'

Ist der SMTP-Server nicht verfügbar, wird eine [MailConnectException] – eine Variante von [MessagingException] – ausgelöst; Ursache ist die [ConnectException] des Sockets:

> mvn compile exec:java -Dexec.args="localhost 27299"
Sender : alice@example.org
Recipients (separated by commas) : bob@example.com
Copy to (Cc) : 
Blind copy to (Bcc) : 
Subject : test
Attachments (separated by commas) : 
Text of the message (ended by an empty line):
text

The following error occurred: MailConnectException : Couldn't connect to host, port: localhost, 27299; timeout -1
Cause: java.net.ConnectException: Connection refused

12.8. Asynchrone Netzwerkprogrammierung: von NIO-Channels zu virtuellen Threads

Mit Ausnahme der [sendAsync]-Anfragen von [HttpClient] verwenden die Programme in diesem Kapitel blockierende Netzwerkoperationen, die von Threads ausgeführt werden (bei Servern von virtuellen Threads). Das ist nicht der einzige Weg, und der Leser wird in bestehendem Code den beiden anderen Modellen begegnen, die Java vor Java 21 bot.

Das erste, in Java 1.4 eingeführte Modell ist die nicht blockierende Ein-/Ausgabe aus dem Paket [java.nio.channels]. Ein [SocketChannel] im nicht blockierenden Modus ([channel.configureBlocking(false)]) gibt die Kontrolle sofort zurück, unabhängig davon, ob Daten zu lesen sind; ein [Selector]-Objekt erlaubt es einem einzigen Thread, eine große Zahl von Channels zu überwachen und geweckt zu werden, sobald einer davon bereit ist (eine neue Verbindung zum Annehmen, Daten zum Lesen, Platz zum Schreiben). Das Programm läuft dann in einer einzigen Schleife, die bei jedem Wecken die bereiten Channels verarbeitet. Die Daten werden blockweise in Byte-Puffer gelesen ([ByteBuffer]): Das Programm muss selbst die Zeilen rekonstruieren – da eine Zeile auf zwei Blöcke verteilt sein kann – und für jeden Client den aktuellen Zustand seiner Sitzung verwalten.

Das zweite, in Java 7 (NIO.2) eingeführte Modell sind die asynchronen Channels: [AsynchronousSocketChannel] und [AsynchronousServerSocketChannel]. Jede Operation wird mit einem Callback-Objekt ([CompletionHandler]) gestartet, dessen Methode [completed] am Ende der Operation von einem Thread aus einem Pool ausgeführt wird. Ein Verbindungsaufbau eines Clients wird so als [channel.connect(address, null, handler)]geschrieben, und die Methode [completed] des Handlers muss den nächsten Lesevorgang starten, dessen Methode [completed] den nächsten startet und so weiter. Der Code ist umfangreich, und die Dialoglogik ist auf mehrere Callback-Methoden verteilt.

Beide Modelle sind effizient: Sie erlauben es einigen wenigen Threads, Tausende von Verbindungen zu bedienen. Sie sind aber schwer zu programmieren und zu debuggen; sie werden vor allem über Bibliotheken wie Netty genutzt, auf denen viele Server basieren. Die virtuellen Threads von Java 21 haben diese Techniken für die meisten Anwendungen überflüssig gemacht: Ein virtueller Thread, der auf eine Netzwerkoperation wartet, blockiert keinen Systemthread, und der Code liest sich in der Reihenfolge, in der er ausgeführt wird, genau wie synchroner Code. Der generische TCP-Client aus Teil 1 ([Internet06.java]) ist ein Beispiel dafür: Ein virtueller Thread liest von der Tastatur, während der Hauptthread aus dem Netzwerk liest, jeweils mit einfachen Aufrufen von [readLine].

Beachten Sie, dass Asynchronität einem Client mit nur einer Verbindung wenig bringt: Sein Thread hat nichts anderes zu tun, als auf die Antwort zu warten. Für einen Server ist sie hingegen unverzichtbar: Ein Server, der seine Clients mit blockierten Plattform-Threads bedient, bindet pro Client einen Systemthread; mit virtuellen Threads oder nicht blockierenden Channels genügen wenige Systemthreads, um eine große Zahl von Clients zu bedienen. Genau das tut der Server in der folgenden Beispielanwendung.

12.9. Beispielanwendung, Version 8: Server zur Steuerberechnung

12.9.1. Die Architektur der neuen Version

Greifen wir die Anwendung zur Steuerberechnung wieder auf. In Version 5 (Kapitel 6) bestand sie aus drei Schichten, jede in einem eigenen Maven-Modul: [dao] (Steuerklassen), [business] (die Berechnung) und [ui] (der Konsolendialog), zusammengefügt durch den Dependency-Injection-Container von Spring; die Versionen 6 und 7 ersetzten die Schicht [dao] durch einen Datenbankzugriff. Wir beginnen mit Version 5, die einfacher auszuführen ist: Die neue Version würde mit der Schicht [dao] aus den Versionen 6 und 7 genauso funktionieren.

Wir werden diese Architektur auf zwei Rechnern bereitstellen:

Image

  • Ein Rechner [server] hostet die Schichten [business] und [dao] aus Version 5. Eine Schicht namens [server] wird so gebaut, dass Clients im Netzwerk den Service zur Steuerberechnung über ein textbasiertes Protokoll namens TCP abfragen können;
  • ein Rechner [client] hostet die Schicht [ui] aus Version 5. Eine neue Schicht [business], die als Client der TCP-Schicht des Servers fungiert, ermöglicht es ihm, den Service zur Steuerberechnung abzufragen.

Die Architektur ändert sich grundlegend: Version 5 war eine Einzelbenutzer-Anwendung; Version 8 wird zu einer Client-Server-Anwendung, und der Server kann mehrere Clients gleichzeitig bedienen. Wir schreiben dennoch nur zwei neue Klassen, [TaxServer] und [TaxBusinessTcp], einen Optionen-Record und zwei Hauptprogramme: Alles andere wird unverändert wiederverwendet.

Das Projekt [TaxV8] ist ein Maven-Projekt mit mehreren Modulen, bestehend aus zwei Modulen, die die Module aus Version 5 verwenden. Diese müssen mit dem Befehl [mvn install], ausgeführt im Ordner [TaxV5] (Kapitel 6), im lokalen Maven-Repository installiert worden sein:

12-internet/TaxV8/
  pom.xml                         parent project: modules, versions, common configuration
  tax-server/
    pom.xml                       dependencies: tax-dao and tax-business (V5), Spring
    server.properties             configuration of the [dao] layer and of the server
    TaxData.txt                   the tax brackets
    src/main/java/tax/server/
      Main.java                   integration of the layers, launch of the server
      ServerOptions.java          the options of the server
      TaxServer.java              the [server] layer
  tax-client/
    pom.xml                       dependencies: tax-business and tax-ui (V5), Spring
    src/main/java/tax/client/
      TaxBusinessTcp.java         the [business] layer of the client: a TCP client
      Main.java                   integration of the layers, dialog

Das übergeordnete Projekt sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<!-- Elternprojekt der Anwendung [Tax], Version 8: ein TCP-Server und sein Client -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>examples.tax</groupId>
    <artifactId>tax-v8</artifactId>
    <version>8.0</version>
    <packaging>pom</packaging>

    <modules>
        <module>tax-server</module>
        <module>tax-client</module>
    </modules>

    <properties>
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- die Schichten aus Version 5 (per mvn install in TaxV5 installiert) und Spring -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>examples.tax</groupId>
                <artifactId>tax-dao</artifactId>
                <version>5.0</version>
            </dependency>
            <dependency>
                <groupId>examples.tax</groupId>
                <artifactId>tax-business</artifactId>
                <version>5.0</version>
            </dependency>
            <dependency>
                <groupId>examples.tax</groupId>
                <artifactId>tax-ui</artifactId>
                <version>5.0</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>7.0.9</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.15.0</version>
                    <configuration>
                        <parameters>true</parameters>
                        <compilerArgs>
                            <arg>-Xlint:all</arg>
                        </compilerArgs>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>exec-maven-plugin</artifactId>
                    <version>3.5.1</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>
  • Zeilen 8–11: Das übergeordnete Projekt mit dem Packaging [pom] hat die Anwendungsversion 8.0;
  • Zeilen 13–16: seine zwei Module;
  • Zeilen 24–47: die Versionen der von den Modulen verwendeten Abhängigkeiten: die drei Module der Version 5 und der Spring-Container;
  • Zeilen 49–70: die gemeinsame Konfiguration für den Compiler und das Plugin zur Ausführung.

12.9.2. Das Kommunikationsprotokoll

Sobald der Client verbunden ist, sendet der Server ihm eine Willkommensnachricht und akzeptiert dann die folgenden Befehle, einen pro Zeile, ohne Beachtung der Groß- und Kleinschreibung:

Befehl
Antwort des Servers
help
eine Liste der akzeptierten Befehle, auf vier Zeilen
tax married nbChildren annualSalary
die Steuer für eine verheiratete Person (married ist [y]) oder unverheiratete Person ([n]) mit [nbChildren] Kindern und einem Jahresgehalt von [annualSalary] Euro, zum Beispiel [4282] als Antwort auf [tax y 2 60000]; oder eine Fehlermeldung in einer Zeile
goodbye
die Nachricht [Goodbye...]; der Server schließt anschließend die Verbindung

Jeder andere Befehl erhält die Antwort [Command not recognized. Use the help command.]

12.9.3. Der Server zur Steuerberechnung

12.9.3.1. Das Modul

Die Datei [pom.xml] des Moduls [tax-server] sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v8</artifactId>
        <version>8.0</version>
    </parent>

    <artifactId>tax-server</artifactId>

    <dependencies>
        <!-- die [dao]- und [business]-Schicht aus Version 5, unverändert wiederverwendet -->
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-dao</artifactId>
        </dependency>
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-business</artifactId>
        </dependency>
        <!-- der Spring-Container für Dependency Injection -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- mvn exec:java führt die Hauptklasse im Ordner des Moduls aus -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <configuration>
                    <mainClass>tax.server.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
  • Zeilen 7–11: Das Modul erbt vom übergeordneten Projekt;
  • Zeilen 17–24: Die Schichten [dao] und [business] aus Version 5 sind Abhängigkeiten ohne Versionsangabe: Die Version wird vom übergeordneten Projekt vorgegeben;
  • Zeilen 26–29: der Dependency-Injection-Container von Spring;
  • Zeilen 35–41: die von [mvn exec:java] ausgeführte Hauptklasse. Wie in Version 5 liest das Programm seine Konfiguration und die Datei mit den Steuerklassen aus dem aktuellen Verzeichnis, also dem Modulverzeichnis, in dem sich die Dateien [server.properties] und [TaxData.txt] befinden.

Die Konfigurationsdatei [server.properties]:

1
2
3
4
5
6
7
# Konfiguration des Steuerberechnungsservers
# die [dao]-Schicht: wie in Version 5
dao.implementation=FileTax
dao.file=TaxData.txt
# der Listening-Port und das Echo des Dialogs mit den Clients im Log
server.port=27200
server.echo=true
  • Zeilen 3–4: die Konfiguration der Schicht [dao], identisch mit der von Version 5: Die Steuerklassen werden aus der Textdatei [TaxData.txt] gelesen;
  • Zeilen 6–7: der Listening-Port des Servers und das Echo des Dialogs mit den Clients im Server-Log. Statt einer Administrationskonsole (mit Befehlen wie [start], [stop], [echo] …) haben wir uns für eine Konfigurationsdatei und das Beenden per Strg-C entschieden, was einfacher ist und der Funktionsweise moderner Server eher entspricht.

12.9.3.2. Das Hauptprogramm

Die Optionen des Servers bilden einen Record:

1
2
3
4
5
package tax.server;

// die Optionen des Servers: Listening-Port und Echo des Dialogs im Log
public record ServerOptions(int port, boolean echo) {
}

Die Klasse [Main] des Servers sieht wie folgt aus:

package tax.server;

import tax.dao.FileTax;
import tax.dao.HardwiredTax;
import tax.dao.ITaxDao;
import tax.dao.JsonTax;
import tax.entities.TaxException;
import tax.business.TaxBusiness;
import java.io.IOException;
import java.io.Reader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Properties;
import org.springframework.context.support.GenericApplicationContext;

// der TCP-Server für die Steuerberechnung: Konfiguration, Integration der Schichten, Ausführung
// Aufruf: mvn exec:java (im Ordner tax-server); Stopp mit Ctrl-C
public class Main {

    public static void main(String[] args) {
        TaxServer server;
        try {
            // Lesen der Konfiguration im aktuellen Ordner
            Properties config = new Properties();
            try (Reader reader = Files.newBufferedReader(Path.of("server.properties"))) {
                config.load(reader);
            }
            String implementation = config.getProperty("dao.implementation", "HardwiredTax");
            String file = config.getProperty("dao.file", "");
            int port = Integer.parseInt(config.getProperty("server.port", "27200"));
            boolean echo = Boolean.parseBoolean(config.getProperty("server.echo", "false"));

            // Registrierung der Schichten im Spring-Container
            GenericApplicationContext context = new GenericApplicationContext();
            // die [dao]-Schicht: die Implementierung wird durch die Konfiguration gewählt (wie in Version 5)
            context.registerBean(ITaxDao.class, () -> switch (implementation) {
                case "HardwiredTax" -> new HardwiredTax();
                case "FileTax" -> new FileTax(file);
                case "JsonTax" -> new JsonTax(file);
                default -> throw new TaxException(
                        "Unknown implementation [" + implementation + "] of the [dao] layer");
            });
            // die [business]-Schicht aus Version 5
            context.registerBean(TaxBusiness.class);
            // die [server]-Schicht: der Container übergibt ihrem Konstruktor die [business]-Schicht
            // und die Optionen des Servers
            context.registerBean(ServerOptions.class, () -> new ServerOptions(port, echo));
            context.registerBean(TaxServer.class);

            // Start des Containers: Erzeugung der Schichten [dao], [business] und [server]
            context.refresh();
            server = context.getBean(TaxServer.class);
        } catch (IOException | RuntimeException e) {
            // Anzeige der Exception-Kette und Stopp
            IO.println("The following error occurred during the initialization of the server:");
            for (Throwable cause = e; cause != null; cause = cause.getCause()) {
                IO.println(cause.getClass().getSimpleName() + " : " + cause.getMessage());
            }
            System.exit(1);
            return;
        }

        // Ctrl-C: der Stopp des Servers wird angefordert, dann warten wir auf das Ende des Haupt-Threads
        Thread main = Thread.currentThread();
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            server.stop();
            try {
                main.join();
            } catch (InterruptedException e) {
                // wir stoppen trotzdem
            }
        }));
        // Ausführung des Servers, bis der Stopp angefordert wird
        server.execute();
    }
}

Wir erkennen das Hauptprogramm aus Version 5 wieder:

  • Zeilen 24–31: das Lesen der Konfiguration. Die Werte sind Zeichenketten: Port und Echo werden umgewandelt, wobei Standardwerte vorgesehen sind;
  • Zeilen 34–44: Die Schichten [dao] und [business] werden genau wie in Version 5 im Container abgelegt;
  • Zeilen 47–48: die Neuerung. Die Optionen des Servers (Port, Echo) werden als Funktion abgelegt, die sie erzeugt, gefolgt von der Schicht [server] selbst. Der Konstruktor von [TaxServer] erwartet ein [ITaxBusiness] und ein [ServerOptions]: Der Container wird sie bereitstellen;
  • Zeile 51: Der Start des Containers erzeugt den Server, was die Erzeugung der Schicht [business] auslöst, die ihrerseits die Erzeugung der Schicht [dao] auslöst; dabei wird die Datei [TaxData.txt] gelesen. Ein Fehler (fehlende oder fehlerhafte Datei) wird angezeigt, und das Programm beendet sich (Zeilen 53–61);
  • Zeilen 64–72: Strg-C löst einen Stopp-Hook aus, der den Server zum Anhalten auffordert und dann wie beim Echo-Server auf das Ende des Hauptthreads wartet;
  • Zeile 74: Der Server läuft, bis ihm das Anhalten befohlen wird.

12.9.3.3. Die Schicht [server]

Die Klasse [TaxServer] sieht wie folgt aus:

package tax.server;

import tax.business.ITaxBusiness;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.function.Consumer;

import static java.nio.charset.StandardCharsets.UTF_8;

// die [server]-Schicht: sie macht die [business]-Schicht über ein TCP-Protokoll aus Textzeilen zugänglich
public class TaxServer {

    // die festen Antworten des Protokolls
    private static final String WELCOME = "Welcome to the tax calculation server";
    private static final String HELP = """
            Accepted commands
            1-help
            2-tax married(Y/N) nbChildren annualSalary
            3-goodbye""";
    private static final String GOODBYE = "Goodbye...";
    private static final String INCORRECT_COMMAND = "Command not recognized. Use the help command.";
    private static final String INCORRECT_CALCULATION = "Incorrect calculation command. Use the help command.";
    private static final DateTimeFormatter TIME = DateTimeFormatter.ofPattern("HH:mm:ss");

    // die [business]-Schicht und die Optionen, vom Konstruktor empfangen
    private final ITaxBusiness business;
    private final ServerOptions options;
    // der lauschende Dienst und die laufenden Dienstverbindungen
    private volatile ServerSocket listener;
    private final Set<Socket> connections = ConcurrentHashMap.newKeySet();
    private volatile boolean stop = false;

    public TaxServer(ITaxBusiness business, ServerOptions options) {
        this.business = business;
        this.options = options;
    }

    // Ausführung des Servers, bis [stop] aufgerufen wird
    public void execute() {
        // ein virtueller Thread pro Client; close() wartet auf das Ende aller Dienste
        try (var listener = new ServerSocket(options.port());
             var services = Executors.newVirtualThreadPerTaskExecutor()) {
            this.listener = listener;
            log("Tax calculation server started on port " + options.port());
            try {
                for (int clientNum = 0; ; clientNum++) {
                    // Warten auf einen Client
                    Socket client = listener.accept();
                    connections.add(client);
                    // er wird von einem virtuellen Thread bedient: wir gehen sofort wieder zum Warten auf den nächsten Client über
                    int number = clientNum;
                    services.submit(() -> serve(client, number));
                }
            } catch (SocketException e) {
                // accept schlägt fehl, wenn [stop] den lauschenden Dienst schließt
                if (!stop) {
                    throw e;
                }
                log("Server stop requested");
                // die laufenden Verbindungen werden geschlossen: die Dienste stoppen
                for (Socket connection : connections) {
                    connection.close();
                }
            }
        } catch (IOException e) {
            log("The following error occurred on the server: " + e.getMessage());
        }
        log("Server stopped");
    }

    // Anforderung, den Server zu stoppen (von einem anderen Thread aufgerufen)
    public void stop() {
        stop = true;
        try {
            if (listener != null) {
                listener.close();
            }
        } catch (IOException e) {
            // der lauschende Dienst wird trotzdem geschlossen
        }
    }

    // der einem Client erbrachte Dienst
    private void serve(Socket client, int clientNum) {
        log("Start of service to client " + clientNum + " (" + client.getRemoteSocketAddress() + ")");
        try (client;
             var reader = new BufferedReader(new InputStreamReader(client.getInputStream(), UTF_8));
             var writer = new PrintWriter(client.getOutputStream(), true, UTF_8)) {
            // Senden einer Antwort an den Client, mit einem möglichen Echo im Log
            Consumer<String> write = response -> {
                if (options.echo()) {
                    log("---> client " + clientNum + " : " + response);
                }
                writer.println(response);
            };
            // Willkommensnachricht
            write.accept(WELCOME);
            // Schleife Anfrage lesen / Antwort schreiben, bis zum Befehl goodbye
            String request;
            while ((request = reader.readLine()) != null) {
                if (options.echo()) {
                    log("<--- client " + clientNum + " : " + request);
                }
                // die in Felder zerlegte Anfrage
                String[] fields = request.strip().toLowerCase().split("\\s+");
                if (fields.length == 1 && fields[0].equals("goodbye")) {
                    write.accept(GOODBYE);
                    break;
                }
                // die Antwort je nach Befehl
                String response = switch (fields[0]) {
                    case "help" -> fields.length == 1 ? HELP : INCORRECT_COMMAND;
                    case "tax" -> calculateTax(fields);
                    default -> INCORRECT_COMMAND;
                };
                write.accept(response);
            }
        } catch (IOException e) {
            if (stop) {
                log("Service to client " + clientNum + " interrupted by the server stop");
            } else {
                log("The following error occurred while serving client " + clientNum + " : "
                        + e.getMessage());
            }
        } finally {
            connections.remove(client);
            log("End of service to client " + clientNum);
        }
    }

    // der Befehl tax married nbChildren annualSalary: liefert die Steuer oder eine Fehlermeldung
    private String calculateTax(String[] fields) {
        // 4 Felder sind erforderlich: tax, y oder n, zwei ganze Zahlen
        if (fields.length != 4 || !fields[1].matches("[yn]")
                || !fields[2].matches("-?\\d{1,9}") || !fields[3].matches("-?\\d{1,9}")) {
            return INCORRECT_CALCULATION;
        }
        try {
            // die Berechnung wird an die [business]-Schicht übergeben
            int tax = business.calculateTax(fields[1].equals("y"), Integer.parseInt(fields[2]),
                    Integer.parseInt(fields[3]));
            return String.valueOf(tax);
        } catch (RuntimeException e) {
            // die Meldung der Exception, in einer einzigen Zeile: das Protokoll besteht aus Textzeilen
            return e.getMessage().replaceAll("\\R", " ");
        }
    }

    // das Log des Servers: jede Zeile hat einen Zeitstempel
    private static void log(String message) {
        IO.println(LocalTime.now().format(TIME) + " " + message);
    }
}
  • Zeilen 24–32: die festen Antworten des Protokolls. Die Antwort auf den Befehl [help], in einem Textblock geschrieben, enthält Zeilenumbrüche: Der Client empfängt sie als vier Zeilen;
  • Zeilen 43–46: Die Klasse erhält die Schicht [business] und ihre Optionen über ihren Konstruktor. Sie kennt nur die Schnittstelle [ITaxBusiness] der Schicht [business] und weiß nichts von der Schicht [dao];
  • Zeilen 49–79: die Warteschleife auf Clients. Sie entspricht der des Echo-Servers aus dem ersten Teil: Jeder Client wird von einem virtuellen Thread bedient, auf den nicht gewartet wird (Zeile 62); das Schließen des Listening-Dienstes beendet das Warten auf einen Client (Zeile 64); danach werden die aktiven Verbindungen geschlossen (Zeilen 71–73), und das Programm wartet vor dem Beenden, bis alle Dienste fertig sind (Schließen des [ExecutorService] beim Verlassen des [try]). Kein Systemthread wird von einem Client blockiert, der nachdenkt;
  • Zeile 53: Der Listening-Dienst wird in einem Feld gespeichert, damit die Methode [stop] ihn schließen kann;
  • Zeilen 82–91: Die Methode [stop], aufgerufen vom Exit-Hook in einem anderen Thread: Deshalb sind die Felder [listener] und [stop] als [volatile] deklariert (Zeilen 39 und 41);
  • Zeilen 94–139: der einem Client angebotene Dienst:
    • Zeilen 100–105: ein Lambda, das die funktionale Schnittstelle [Consumer<String>] implementiert, eine Antwort an den Client sendet und sie, wenn das Echo aktiviert ist, auch ins Log schreibt;
    • Zeile 107: Sobald der Client verbunden ist, sendet der Server ihm eine Willkommensnachricht;
    • Zeile 110: die Schleife zum Lesen der Befehle, die endet, wenn der Client die Verbindung schließt oder der Server heruntergefahren wird;
    • Zeile 115: Der Befehl wird in Kleinbuchstaben umgewandelt und in Felder zerlegt. Der reguläre Ausdruck [\s+] (ein oder mehrere Leerzeichen) verhindert leere Felder durch mehrere aufeinanderfolgende Leerzeichen;
    • Zeilen 116–119: Der Befehl besteht ausschließlich aus dem Wort [goodbye]. Der Server antwortet und verlässt die Schleife: Die Verbindung wird beim Verlassen des [try] with resources geschlossen;
    • Zeilen 121–125: Ein [switch] -Ausdruck wählt die Antwort anhand des ersten Feldes: [help] allein, ein Befehl, der mit [tax] beginnt, oder jeder andere Befehl. Eine leere Zeile erhält die Antwort [Command not recognized];
  • Zeilen 142–157: die Steuerberechnung:
    • Zeilen 144–147: Der Befehl muss vier Felder haben, wobei das zweite Feld [y] oder [n] ist und die letzten beiden Felder ganze Zahlen sind (ein bis neun Ziffern, gegebenenfalls mit einem Minuszeichen davor: [parseInt] führt dann zu keinem Fehler);
    • Zeilen 150–152: Die Berechnung wird bei der Schicht [business] angefordert. Eine einzige Instanz von [TaxBusiness] bedient alle Clients, möglicherweise gleichzeitig aus verschiedenen Threads: Das ist möglich, weil diese Klasse nach ihrer Konstruktion keine Daten mehr verändert (ihre Liste der Steuerklassen ist schreibgeschützt);
    • Zeilen 153–156: Löst die Schicht [business] eine Exception aus (zum Beispiel wegen einer negativen Kinderzahl), wird ihre Meldung an den Client zurückgegeben. Diese Meldung kann Zeilenumbrüche enthalten: Sie werden durch Leerzeichen ersetzt ([\R] steht für einen beliebigen Zeilenumbruch), da das Protokoll eine einzeilige Antwort verlangt;
  • Zeilen 160–162: das Server-Log auf der Konsole: Jeder Zeile ist die Uhrzeit vorangestellt, wodurch sich der Ablauf nebenläufiger Dienste nachvollziehen lässt. [IO.println] kann ohne Weiteres aus mehreren Threads aufgerufen werden: Seine Schreibvorgänge stören sich nicht.

12.9.4. Der Client des Servers zur Steuerberechnung

Der Client verwendet die Konsolenoberfläche aus Version 5 – die Klasse [tax.ui.Dialog] – unverändert wieder.

12.9.4.1. Die Schicht [business] des Clients

Die Schicht [ui] kommuniziert mit einer Schicht [business], von der sie nur die Schnittstelle [ITaxBusiness] aus Version 5 kennt, reduziert auf eine einzige Methode: [int calculateTax(boolean married, int nbChildren, int salary)].

Es genügt daher, ihr eine andere Implementierung dieser Schnittstelle zu liefern, die die Steuer nicht berechnet, sondern beim Server anfordert. Das ist die Klasse [TaxBusinessTcp]:

package tax.client;

import tax.entities.TaxException;
import tax.business.ITaxBusiness;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

import static java.nio.charset.StandardCharsets.UTF_8;

// die [business]-Schicht des Clients: sie implementiert ITaxBusiness, indem sie die Berechnung an den TCP-Server delegiert
public class TaxBusinessTcp implements ITaxBusiness, AutoCloseable {

    // die Verbindung zum Server, für die gesamte Lebensdauer des Objekts geöffnet
    private final Socket client;
    private final BufferedReader reader;
    private final PrintWriter writer;

    // Verbindung zum Server (Rechner, Port)
    public TaxBusinessTcp(String machine, int port) {
        try {
            client = new Socket(machine, port);
            reader = new BufferedReader(new InputStreamReader(client.getInputStream(), UTF_8));
            writer = new PrintWriter(client.getOutputStream(), true, UTF_8);
            // der Server spricht zuerst: seine Willkommensnachricht wird gelesen (und ignoriert)
            readResponse();
        } catch (IOException e) {
            throw new TaxException("Unable to connect to the server (" + machine + ", " + port + ")",
                    e, 21);
        }
    }

    // Steuerberechnung: eine Anfrage, eine Antwort
    @Override
    public int calculateTax(boolean married, int nbChildren, int salary) {
        String response;
        try {
            writer.println("tax " + (married ? "y" : "n") + " " + nbChildren + " " + salary);
            response = readResponse();
        } catch (IOException e) {
            throw new TaxException("Error communicating with the server", e, 22);
        }
        // der Server liefert die Steuer oder eine Fehlermeldung
        try {
            return Integer.parseInt(response);
        } catch (NumberFormatException e) {
            throw new TaxException("The server answered: " + response, 23);
        }
    }

    // Lesen einer Antwortzeile; null bedeutet, dass der Server die Verbindung geschlossen hat
    private String readResponse() throws IOException {
        String response = reader.readLine();
        if (response == null) {
            throw new TaxException("The server has closed the connection", 24);
        }
        return response;
    }

    // Ende der Verbindung: wir verabschieden uns vom Server, falls er noch da ist
    @Override
    public void close() {
        try (client) {
            writer.println("goodbye");
            reader.readLine();
        } catch (IOException e) {
            // die Verbindung ist bereits unterbrochen: es ist nichts mehr zu tun
        }
    }
}
  • Zeile 14: Die Klasse implementiert [ITaxBusiness]. Sie implementiert außerdem [AutoCloseable]: Sie hält eine Netzwerkverbindung offen, die geschlossen werden muss;
  • Zeilen 17–19: die Verbindung zum Server und ihre Lese- und Schreibströme. Wir öffnen eine einzige Verbindung, die für alle Berechnungen einer Sitzung verwendet wird, statt einer Verbindung pro Berechnung: Das ist effizienter, und der Server sieht einen Client pro Benutzersitzung;
  • Zeilen 22–33: Der Konstruktor verbindet sich mit dem Server und liest dessen Willkommensnachricht (Zeile 28). Ein Verbindungsfehler wird in eine [TaxException], die Anwendungs-Exception, mit dem Code 21 eingekapselt;
  • Zeilen 37–51: die Steuerberechnung. Der Befehl [tax y 2 60000] wird an den Server gesendet (Zeile 40) und seine Antwort gelesen. Ist die Antwort eine ganze Zahl, ist sie der Steuerbetrag; andernfalls handelt es sich um eine Fehlermeldung des Servers, die in einer [TaxException] weitergegeben wird (Zeile 49): Würde man die Antwort direkt in eine ganze Zahl umwandeln, würde im Fall einer Fehlermeldung eine Umwandlungs-Exception ausgelöst, die die wahre Fehlerursache verdecken würde;
  • Zeilen 54–60: [readLine] liefert [null] , wenn der Server die Verbindung geschlossen hat: Dann wird eine [TaxException] ausgelöst;
  • Zeilen 64–71: das Ende der Verbindung. Der Client verabschiedet sich mit dem Befehl [goodbye] vom Server, liest dessen Antwort und schließt dann die Verbindung ([try (client)]). Hat der Server die Verbindung bereits beendet, wird die dabei entstehende [IOException] ignoriert.

Diese Klasse verwendet die blockierenden Methoden von [Socket], wie alle Clients in diesem Kapitel: Die Schnittstelle [ITaxBusiness] aus Version 5 ist synchron ([calculateTax] liefert ein [int], kein [CompletableFuture<Integer>]), und für ein Konsolenprogramm, das nur einen Benutzer bedient, ist das völlig angemessen: Der Hauptthread hat nichts anderes zu tun, als auf die Antwort zu warten. Sollten mehrere Berechnungen parallel ausgeführt werden, würde [calculateTax] aus mehreren virtuellen Threads aufgerufen (mit einer Verbindung pro Thread, da [TaxBusinessTcp] nicht für die gleichzeitige Nutzung durch mehrere Threads ausgelegt ist).

12.9.4.2. Das Hauptprogramm des Clients

Das Modul [tax-client] hängt von der Schicht [business] und der Schicht [ui] aus Version 5 ab:

    <dependencies>
        <!-- die Schnittstelle der [business]-Schicht und die [ui]-Schicht aus Version 5 -->
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-business</artifactId>
        </dependency>
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-ui</artifactId>
        </dependency>
        <!-- der Spring-Container für Dependency Injection -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
    </dependencies>

Das Modul [tax-ui] in Version 5 enthält eine Anwendung (seine Klasse [Main]); es kann jedoch als Bibliothek für seine öffentliche Klasse [tax.ui.Dialog] verwendet werden. Die Client-Klasse [Main] sieht wie folgt aus:

package tax.client;

import tax.business.ITaxBusiness;
import tax.ui.Dialog;
import org.springframework.context.support.GenericApplicationContext;

// der Konsolenclient des Steuerberechnungsservers
// Aufruf: mvn exec:java [-Dexec.args="machine port"]   (standardmäßig: localhost 27200)
public class Main {

    public static void main(String[] args) {
        String machine = args.length > 0 ? args[0] : "localhost";
        int port = args.length > 1 ? Integer.parseInt(args[1]) : 27200;

        // der Spring-Container wird beim Verlassen des try geschlossen: er schließt dann die AutoCloseable-Objekte,
        // die er erzeugt hat
        try (var context = new GenericApplicationContext()) {
            // die [business]-Schicht ist nun ein TCP-Client des Steuerberechnungsservers
            context.registerBean(ITaxBusiness.class, () -> new TaxBusinessTcp(machine, port));
            // Start des Containers: Erzeugung der [business]-Schicht, also Verbindung zum Server
            context.refresh();
            ITaxBusiness business = context.getBean(ITaxBusiness.class);
            IO.println("Connected to the tax calculation server (" + machine + ", " + port + ")");
            // die [ui]-Schicht aus Version 5, unverändert
            Dialog.run(business);
        } catch (RuntimeException e) {
            // Verbindungs- oder Kommunikationsfehler: Anzeige der Exception-Kette
            Dialog.displayError(e);
        }
    }
}
  • Zeilen 12–13: der Rechner und der Port des Servers, als Argumente übergeben, mit Standardwerten;
  • Zeile 17: Der Spring-Container wird in einem [try] with resources deklariert. Wird er am Ende des Programms geschlossen, ruft er die Methode [close] der von ihm erzeugten [AutoCloseable]-Objekte auf: Die Verbindung von [TaxBusinessTcp] wird ordnungsgemäß geschlossen;
  • Zeile 19: Die im Container abgelegte Schicht [business] ist nun [TaxBusinessTcp]. Da ihr Konstruktor zwei Parameter erwartet, die der Container nicht kennt, wird für sie eine Erzeugungsfunktion bereitgestellt;
  • Zeile 21: Beim Start des Containers erzeugt dieser die Schicht [business] und verbindet sich dadurch mit dem Server;
  • Zeile 25: der Dialog aus Version 5, unverändert. Die Schicht [ui] weiß nicht, dass die Steuer von einem entfernten Server berechnet wird;
  • Zeilen 26–29: Ein Verbindungs- oder Kommunikationsfehler wird von der Methode [displayError] aus Version 5 angezeigt.

12.9.5. Ausführungen

Der Server wird in einem Befehlsfenster aus dem Ordner [tax-server] mit [mvn compile exec:java] gestartet, wobei die Module der Version 5 wie oben beschrieben installiert worden sein müssen. In einem anderen Fenster wird der Client aus dem Ordner [tax-client] gestartet:

> mvn compile exec:java
Connected to the tax calculation server (localhost, 27200)
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: x 2 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect Married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y two 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Der Dialog ist exakt derselbe wie in Version 5: Er zeigt die Validierungswerte an (4.282 und 2.959 für eine verheiratete Person mit 2 bzw. 3 Kindern und einem Gehalt von 60.000 Euro; 11.519 für eine unverheiratete Person ohne Kinder) und dieselben Fehlermeldungen bei fehlerhaften Eingaben. Diese Meldungen werden von der Schicht [ui] des Clients erzeugt, die die Eingaben validiert, bevor sie die Berechnung anfordert: Fehlerhafte Eingaben erreichen den Server nie.

Starten wir nun zwei Clients, A und B, in zwei Fenstern, wobei B startet, während A noch verbunden ist. Jeder führt zwei Berechnungen durch. Im Fenster von Client A:

1
2
3
4
5
6
7
> mvn compile exec:java
Connected to the tax calculation server (localhost, 27200)
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 2 40000
Tax=2854 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Im Fenster von Client B:

1
2
3
4
5
6
7
> mvn compile exec:java
Connected to the tax calculation server (localhost, 27200)
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Um die Antworten des Servers auf fehlerhafte Befehle zu sehen, benötigt man einen Client, der die Befehle genau so sendet, wie sie eingegeben werden: Der generische TCP-Client aus dem ersten Teil eignet sich hervorragend. Der Server spricht zuerst, was dieser Client bewältigen kann:

> java Internet06.java localhost 27200
Type your commands (bye to stop):
<-- Welcome to the tax calculation server
help
<-- Accepted commands
<-- 1-help
<-- 2-tax married(Y/N) nbChildren annualSalary
<-- 3-goodbye
tax y 2 60000
<-- 4282
TAX N 0 60000
<-- 11519
tax x 2 60000
<-- Incorrect calculation command. Use the help command.
tax y 2
<-- Incorrect calculation command. Use the help command.
tax y -2 60000
<-- nbChildren (-2) must be positive or zero
calculation
<-- Command not recognized. Use the help command.
goodbye
<-- Goodbye...
[the server closed the connection]
  • Zeile 3: die Willkommensnachricht, unmittelbar nach dem Verbindungsaufbau empfangen;
  • Zeilen 5–8: die Antwort auf den Befehl [help], über vier Zeilen;
  • Zeilen 11–12: Die Groß- und Kleinschreibung des Befehls wird ignoriert;
  • Zeilen 13–16: zwei fehlerhaft aufgebaute Berechnungsbefehle;
  • Zeilen 17–18: Der Befehl ist wohlgeformt, aber die Schicht [business] lehnt eine negative Kinderzahl ab; die Meldung der Exception wurde zurückgegeben;
  • Zeilen 19–20: ein unbekannter Befehl;
  • Zeilen 21–23: Nach dem Befehl [goodbye] hat der Server die Verbindung geschlossen, und der Client hat sich von selbst beendet.

Der Server wird dann mit Strg-C beendet, während noch ein letzter Client verbunden ist. Dieser Client führte vor dem Beenden eine erste Berechnung durch und sendete seine zweite Anfrage danach:

1
2
3
4
5
6
7
8
9
> mvn compile exec:java
Connected to the tax calculation server (localhost, 27200)
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Exception chain:
----------------------------------------
tax.entities.TaxException: The server has closed the connection
----------------------------------------

Das Lesen der Antwort lieferte [null]: Die Schicht [business] löste eine [TaxException] aus, die das Hauptprogramm anzeigte. Sobald der Server gestoppt ist, kann sich kein neuer Client mehr verbinden:

> mvn compile exec:java
Oct 03, 2026 7:43:33 PM org.springframework.context.support.GenericApplicationContext refresh
WARNING: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.business.ITaxBusiness': Instantiation of supplied bean failed
Exception chain:
----------------------------------------
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.business.ITaxBusiness': Instantiation of supplied bean failed
----------------------------------------
tax.entities.TaxException: Unable to connect to the server (localhost, 27200)
----------------------------------------
java.net.ConnectException: Connection refused
----------------------------------------

Der Konstruktor von [TaxBusinessTcp] löste eine [TaxException] aus, verursacht durch die [ConnectException] des Sockets. Da er beim Start vom Spring-Container aufgerufen wurde, kapselte der Container sie in eine [BeanCreationException] ein, die an der Spitze der Exception-Kette steht. Die ersten beiden Zeilen sind eine Warnung, die Spring in sein Log geschrieben hat (auf die Fehlerausgabe, im Standard-Log-Format von Java): Der Start des Containers ist fehlgeschlagen.

Zum Schluss folgt das Server-Log all dieser Tests:

> mvn compile exec:java
19:42:50 Tax calculation server started on port 27200
19:42:52 Start of service to client 0 (/127.0.0.1:44044)
19:42:52 ---> client 0 : Welcome to the tax calculation server
19:42:54 <--- client 0 : tax y 2 60000
19:42:54 ---> client 0 : 4282
19:42:55 <--- client 0 : tax y 3 60000
19:42:55 ---> client 0 : 2959
19:42:56 <--- client 0 : tax n 0 60000
19:42:56 ---> client 0 : 11519
19:42:58 <--- client 0 : goodbye
19:42:58 ---> client 0 : Goodbye...
19:42:58 End of service to client 0
19:43:00 Start of service to client 1 (/127.0.0.1:54654)
19:43:00 ---> client 1 : Welcome to the tax calculation server
19:43:02 <--- client 1 : tax y 2 60000
19:43:02 ---> client 1 : 4282
19:43:03 Start of service to client 2 (/127.0.0.1:54662)
19:43:03 ---> client 2 : Welcome to the tax calculation server
19:43:05 <--- client 2 : tax y 3 60000
19:43:05 ---> client 2 : 2959
19:43:05 <--- client 1 : tax n 2 40000
19:43:05 ---> client 1 : 2854
19:43:08 <--- client 2 : tax n 0 60000
19:43:08 ---> client 2 : 11519
19:43:08 <--- client 1 : goodbye
19:43:08 ---> client 1 : Goodbye...
19:43:08 End of service to client 1
19:43:11 <--- client 2 : goodbye
19:43:11 ---> client 2 : Goodbye...
19:43:11 End of service to client 2
19:43:13 Start of service to client 3 (/127.0.0.1:45664)
19:43:13 ---> client 3 : Welcome to the tax calculation server
19:43:14 <--- client 3 : help
19:43:14 ---> client 3 : Accepted commands
1-help
2-tax married(Y/N) nbChildren annualSalary
3-goodbye
19:43:15 <--- client 3 : tax y 2 60000
19:43:15 ---> client 3 : 4282
19:43:16 <--- client 3 : TAX N 0 60000
19:43:16 ---> client 3 : 11519
19:43:17 <--- client 3 : tax x 2 60000
19:43:17 ---> client 3 : Incorrect calculation command. Use the help command.
19:43:18 <--- client 3 : tax y 2
19:43:18 ---> client 3 : Incorrect calculation command. Use the help command.
19:43:19 <--- client 3 : tax y -2 60000
19:43:19 ---> client 3 : nbChildren (-2) must be positive or zero
19:43:20 <--- client 3 : calculation
19:43:20 ---> client 3 : Command not recognized. Use the help command.
19:43:21 <--- client 3 : goodbye
19:43:21 ---> client 3 : Goodbye...
19:43:21 End of service to client 3
19:43:25 Start of service to client 4 (/127.0.0.1:43690)
19:43:25 ---> client 4 : Welcome to the tax calculation server
19:43:27 <--- client 4 : tax y 2 60000
19:43:27 ---> client 4 : 4282
19:43:30 Server stop requested
19:43:30 Service to client 4 interrupted by the server stop
19:43:30 End of service to client 4
19:43:30 Server stopped
  • Zeilen 3–13: der Client des ersten Laufs. Mit dem Echo-Befehl sehen wir alle empfangenen Befehle und alle gesendeten Antworten. Beachten Sie den Befehl [goodbye] (Zeile 11), der von der Methode [close] von [TaxBusinessTcp] beim Herunterfahren des Spring-Containers gesendet wurde: Die Sitzung wurde ordnungsgemäß beendet;
  • Zeilen 14–31: die Clients A (Client 1) und B (Client 2). Client 2 kam an (Zeile 18), während Client 1 noch bedient wurde, und ihre Anfragen wurden abwechselnd in der Reihenfolge ihres Eintreffens bearbeitet: Der Server bedient tatsächlich mehrere Clients gleichzeitig;
  • Zeilen 32–53: die Sitzung des generischen TCP-Clients;
  • Zeilen 54–61: der letzte Client, der zum Zeitpunkt des Herunterfahrens bedient wurde. Strg-C schloss den Listening-Dienst, was das Warten auf einen neuen Client beendete; der Server schloss die Verbindung von Client 4, dessen Dienst-Thread – der auf einen Befehl wartete – sich beendete, und dann fuhr der Server herunter.

12.9.6. Fazit

Wieder einmal konnten wir bestehenden Code unverändert wiederverwenden: die Schichten [dao] und [business] der Version 5 auf Serverseite und die Schicht [ui] auf Clientseite, verwendet als Maven-Bibliotheken. Möglich wurde das durch den konsequenten Einsatz von Schnittstellen und Dependency Injection: Um die Anwendung auf zwei Rechnern bereitzustellen, genügte es, über der Schicht [server] eine Schicht [business] hinzuzufügen und der Schicht [ui] eine andere Implementierung von [ITaxBusiness] zu geben. Hätte Version 1 die Steuerberechnung und die Benutzerinteraktion im selben Programm vermischt, wäre nichts davon wiederverwendbar gewesen. Beachten Sie, dass die Schicht [ui] nicht weiß, dass ein entfernter Server den Steuerbetrag berechnet.

Unser hauseigenes Protokoll hat jedoch seine Grenzen: Wir müssen den Server schreiben, Verbindungen verwalten, Befehle analysieren und Antworten umwandeln, und ein in einer anderen Sprache geschriebener Client müsste dieses spezielle Protokoll kennen. Version 9 im nächsten Kapitel wird den TCP-Server durch einen Webservice ersetzen: Das Protokoll wird HTTP sein, die Daten werden über JSON ausgetauscht, und der Client wird [HttpClient] verwenden.

12.10. Fazit

Dieses Kapitel hat in die Internetprogrammierung in Java eingeführt, ausgehend von den Grundlagen bis hin zu Klassen auf hoher Abstraktionsebene:

  • Der erste Teil hat die Funktionsweise der Internetprotokolle (IP, TCP, UDP, DNS) und der textbasierten Anwendungsprotokolle (HTTP, SMTP, POP, FTP) wiederholt und dann die Klassen [InetAddress] und [NetworkInterface] sowie die Klassen [Socket] und [ServerSocket] vorgestellt. Mit diesen Klassen und einem virtuellen Thread pro Client haben wir Server geschrieben, die mehrere Clients gleichzeitig bedienen, generische TCP-Clients und einen Webclient, der „manuell“ über HTTP kommunizierte;
  • Der zweite Teil hat auf ein Protokoll spezialisierte Klassen vorgestellt. Für HTTP ersetzt die Klasse [HttpClient] aus Java 11 die Klassen [URL] und [HttpURLConnection]: Sie erledigt in wenigen Anweisungen, was unser TCP-Client früher in fünfzig Zeilen tat, behandelt Weiterleitungen, Formulare, Timeouts, Abbrüche und asynchrone Anfragen und ist darauf ausgelegt, über mehrere Anfragen hinweg wiederverwendet zu werden; in Verbindung mit Jackson tauscht sie Objekte im JSON-Format aus. Für SMTP erstellt die Bibliothek Jakarta Mail die MIME-Nachrichten und übernimmt die Kommunikation mit dem Server;
  • Die Beispielanwendung ist ohne jede Änderung an ihren bestehenden Schichten zu einer Client-Server-Anwendung geworden.

Die virtuellen Threads, die in Kapitel 8 behandelt wurden, haben hier ihre wichtigste Anwendung gefunden: Ein Server bedient eine große Zahl von Clients mit nur wenigen Systemthreads und behält dabei die einfache Codestruktur eines Threads pro Client bei. Dennoch bleibt es die Ausnahme, einen TCP-Server zu schreiben und ein eigenes Protokoll zu erfinden: Die meisten verteilten Anwendungen kommunizieren heute über HTTP, mithilfe von Webservices, die JSON-Daten austauschen. Das ist das Thema des nächsten Kapitels.