Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger

 << zurück
Java ist auch eine Insel von Christian Ullenboom
Programmieren für die Java 2-Plattform in der Version 5
Java ist auch eine Insel

Java ist auch eine Insel
5., akt. und erw. Auflage
1454 S., mit CD, 49,90 Euro
Galileo Computing
ISBN 3-89842-747-1
gp Kapitel 16 Das Netz
  gp 16.1 Grundlegende Begriffe
    gp 16.1.1 Internet-Standards und RFC
  gp 16.2 URI und URL
    gp 16.2.1 URI
    gp 16.2.2 Die Klasse URL
    gp 16.2.3 Informationen über eine URL
    gp 16.2.4 Der Zugriff auf die Daten über die Klasse URL
    gp 16.2.5 Verbindungen durch einen Proxy-Server
  gp 16.3 Die Klasse URLConnection
    gp 16.3.1 Methoden und Anwendung von URLConnection
    gp 16.3.2 Protokoll- und Content-Handler
    gp 16.3.3 Bilder-Handler
    gp 16.3.4 Zusammenfassung Content- und Protokoll-Handler
    gp 16.3.5 Im Detail: vom URL zu URLConnection
    gp 16.3.6 Der Protokoll-Handler für Jar-Dateien
    gp 16.3.7 Autorisierte URL-Verbindungen und Proxy-Authentifizierung mit Basic Authentication
  gp 16.4 Das Common Gateway Interface
    gp 16.4.1 Parameter für ein CGI-Programm
    gp 16.4.2 Kodieren der Parameter für CGI-Programme
    gp 16.4.3 Eine Suchmaschine ansprechen
  gp 16.5 Host- und IP-Adressen
    gp 16.5.1 Lebt der Rechner?
    gp 16.5.2 Das Netz ist Klasse …
    gp 16.5.3 IP-Adresse des lokalen Hosts
  gp 16.6 NetworkInterface
  gp 16.7 Mit dem Socket zum Server
    gp 16.7.1 Das Netzwerk ist der Computer
    gp 16.7.2 Sockets
    gp 16.7.3 Standarddienste unter Windows nachinstallieren
    gp 16.7.4 Eine Verbindung zum Server aufbauen
    gp 16.7.5 Server unter Spannung: die Ströme
    gp 16.7.6 Die Verbindung wieder abbauen
    gp 16.7.7 Ein kleines Echo – lebt der Rechner noch?
    gp 16.7.8 Blockierendes Lesen
    gp 16.7.9 Informationen über den Socket
    gp 16.7.10 Mit telnet an den Ports horchen
    gp 16.7.11 Reine Verbindungsdaten über SocketAddress
  gp 16.8 Client/Server-Kommunikation
    gp 16.8.1 Warten auf Verbindungen
    gp 16.8.2 Ein Multiplikations-Server
    gp 16.8.3 Von außen erreichbar sein
  gp 16.9 SSL-Verbindungen mit JSSE
  gp 16.10 Apache Jakarta Commons HttpClient und Net
    gp 16.10.1 Jakarta Commons HttpClient
    gp 16.10.2 Jakarta Commons Net
  gp 16.11 E-Mail
    gp 16.11.1 Wie eine E-Mail um die Welt geht
    gp 16.11.2 Das Simple Mail Transfer Protocol und RFC 822
    gp 16.11.3 POP (Post Office Protocol)
    gp 16.11.4 E-Mails versenden mit der JavaMail API von SUN
    gp 16.11.5 MimeMultipart-Nachrichten schicken
    gp 16.11.6 E-Mails mittels POP3 abrufen
    gp 16.11.7 Ereignisse und Suchen
  gp 16.12 Arbeitsweise eines Web-Servers
    gp 16.12.1 Das Hypertext Transfer Protocol (HTTP)
    gp 16.12.2 Anfragen an den Server
    gp 16.12.3 Die Antworten vom Server
  gp 16.13 Datagram-Sockets
    gp 16.13.1 Die Klasse DatagramSocket
    gp 16.13.2 Datagramme und die Klasse DatagramPacket
    gp 16.13.3 Auf ein hereinkommendes Paket warten
    gp 16.13.4 Ein Paket zum Senden vorbereiten
    gp 16.13.5 Methoden der Klasse DatagramPacket
    gp 16.13.6 Das Paket senden
  gp 16.14 Tiefer liegende Netzwerkeigenschaften
    gp 16.14.1 Internet Control Message Protocol (ICMP)
    gp 16.14.2 MAC-Adresse
  gp 16.15 Multicast-Kommunikation


Galileo Computing

16.13 Datagram-Sockets  downtop

Neben den Stream-Sockets gibt es im java.net-Paket eine weitere Klasse, die auch den verbindungslosen Pakettransport erlaubt. Dabei handelt es sich um die Klasse DatagramSocket. Datagram-Sockets basieren auf dem User Datagram Protocol (UDP). Letzteres ist auf dem Internet-Protokoll aufgesetzt und erlaubt eine ungesicherte Übertragung – da es auf der Transportschicht des OSI-Modells (Schicht 4) angeordnet ist. Auch UDP erlaubt es einer Applikation, einen Service über einen Port zu kontaktieren. Genau wie TCP nutzt auch UDP verschiedene Port-Nummern, sodass mehrere Server unter unterschiedlichen Ports ihre Dienste anbieten können. Wichtig ist, dass UDP-Ports völlig eigenständig sind und mit TCP-Ports nichts gemeinsam haben. So kann ein Server-Socket für TCP am Port 4711 horchen und ein Datagram-Socket ebenso, doch lässt sich für ein Programm nicht unbedingt jeder Port nutzen, da etwa das Unix-Betriebssystem einige Ports reserviert beziehungsweise wir nicht unter die 1024-Grenze kommen. Wir werden später ein Programm kennen lernen, welches freie Ports überprüft.

Die Datagram-Sockets benötigen im Gegensatz zu den Stream-Sockets keine feste Verbindung zum Server; jedes Datagramm wird einzeln verschickt und kann folglich auf unterschiedlichen Wegen und in verschiedener Reihenfolge am Client ankommen. So ist der Ausdruck »verbindungslos« zu verstehen. Die Datagramme sind von den anderen völlig unabhängig. Ist die Ordnung der Pakete relevant, muss über ein Zeitfeld dann die richtige Reihenfolge rekonstruiert werden.

Datagram-Sockets und Stream-Sockets im Vergleich

Stream-Sockets nutzen eine TCP/IP-Verbindung und die Fähigkeit, Daten in der richtigen Reihenfolge zu sortieren. Arbeiten wir also mit Stream-Sockets oder auch mit der URL-Klasse, so müssen wir uns um den Transport nicht kümmern. Wir werden also bei der Benutzung von Stream-Sockets von den unteren Netzwerkschichten getrennt, die die richtige Reihenfolge der Pakete garantieren. Datagram-Sockets nutzen ein anderes Protokoll: das UDP-Protokoll. Dabei wird nur ein einzelner Chunk – durch die Klasse DatagramPacket repräsentiert – übertragen, dessen Größe wir fast frei bestimmen können. Da jedoch UDP wie TCP das IP-Protokoll nutzen, ist die Größe eines Datagramms durch das Internet-Protokoll beschränkt und beträgt maximal 64 KB (65 535 Byte). Davon werden allerdings einige Byte für den Header benötigt, für Daten wie Sender- und Empfängeradresse und Port-Nummer. Eine Checksumme wie CRC ist nicht nötig. Ziehen wir die Byte für den Header ab, beträgt der nutzbare Bereich 65 507 Byte. Mehr Daten können wir mit einer Übertragung nicht senden. Es ist somit unsere Aufgabe, größere Pakete zu zerteilen.

TCP würde diese Pakete dann wieder richtig zusammensetzen, doch UDP leistet dies nicht. Deswegen garantiert UDP auch nicht, dass die Reihenfolge der Pakete richtig ist. Da UDP nicht mit verlorenen Paketen umgehen kann, ist nicht gewährleistet, dass alle Daten übertragen werden. Die Anwendung muss sich also selbst darum kümmern. Das hört sich jetzt alles mehr nach einem Nachteil als nach einem Vorteil an. Warum werden dann überhaupt Datagram-Sockets verwendet? Die Antwort ist einfach: Datagram-Sockets sind schnell. Da die Verbindung nicht verbindungsorientiert ist wie TCP/IP, lassen sich der Aufwand für die korrekte Reihenfolge und weitere Leistungen sparen. Verbindungslose Protokolle wie eben UDP bauen keine Verbindung zum Empfänger auf und senden dann die Daten, sondern sie senden einfach die Daten und lassen sie von den Zwischenstationen verteilen. UDP profitiert also davon, dass die Bestätigung der Antwort und die erlaubte Möglichkeit des Sendens nicht vereinbart werden. UDP sendet seine Pakete demnach einfach in den Raum, und es ist egal, ob sie ankommen oder nicht.

Da allerdings Pakete verloren gehen können, würden wir Datagram-Sockets nicht für große Daten verwenden. Für kleine, häufiger übermittelte Daten eignet sich das Protokoll besser. Nehmen wir einmal an, ein Server sendet Börsendaten für die Interessenten. Dafür ist das UDP-Protokoll gut geeignet, denn die anfragenden Clients können auf ein Datenpaket vermutlich verzichten. Wir können davon ausgehen, dass der Server in regelmäßigen Abständen neue Pakete sendet. Hier geht also Geschwindigkeit vor Sicherheit. Bei einer Audio-Übertragung ist es beispielsweise besser, wenn das Paket verschwindet, als wenn das Paket erst zwei Minuten später ankommt und dann abgespielt wird. Das bedeutet, UDP kann überall dort eingesetzt werden, wo eine Empfangsbestätigung nicht relevant ist. Erhält ein Client innerhalb einer gewissen Zeit keine Antwort, so stellt er seine Anfrage einfach erneut. Wichtige Applikationen, die UDP nutzen, sind das Domain Name System (DNS), TFTP (Trivial File Transfer Protocol) und auch Suns Network Filesystem (NFS). NFS ist so ausgelegt, dass verloren gegangene Pakete wieder besorgt werden.

Welche Klasse für welche Übertragung?

Im Gegensatz zu TCP-Verbindungen gibt es bei UDP-Verbindungen kein Objekt wie Socket oder ServerSocket für Client und Server. Das liegt daran, dass es in UDP kein Konzept wie virtuelle Verbindungen gibt und die Adresse nicht im Socket gespeichert ist, sondern im Paket selbst. Die Dateneinheiten sind Datagramme, und nach einer Kommunikation wissen die Partner schon nichts mehr übereinander. Bei UPD verwenden beide die Klasse DatagramSocket, die für eine eingehende und auch ausgehende Verbindung steht.


Tabelle 16.5   Welche Klasse wofür?

Klasse Protokoll Verbindungstyp Richtung
Socket TCP Verbindungsorientiert, korrekte Reihenfolge Ausgehend
ServerSocket TCP Verbindungsorientiert, korrekte Reihenfolge Hereinkommend
DatagramSocket UDP Verbindungslos, Datagramme, beliebige Reihenfolge Ausgehend und hereinkommend


Galileo Computing

16.13.1 Die Klasse DatagramSocket  downtop

Damit wir später einmal ein Paket (durch die Klasse DatagramPacket repräsentiert) senden können, erzeugen wir zunächst ein DatagramSocket-Objekt. Dieses Objekt steht für einen Kommunikationspunkt auf unserer Rechnerseite. Im Konstruktor wird hier noch nicht die IP-Adresse des Empfängers eingegeben. Dies geschieht später durch DatagramPacket, da diese Informationen nur im Paket kodiert sind.


class java.net.  DatagramSocket  

gp  DatagramSocket() throws SocketException
gp  DatagramSocket( int port ) throws SocketException
gp  DatagramSocket( int port, InetAddress laddr ) throws SocketException
gp  DatagramSocket( SocketAddress bindaddr ) throws SocketException

Häufig wird der erste Konstruktor für Client-Programme verwendet, die beiden anderen nutzt der Server. Der Unterschied in den Konstruktoren liegt darin, an welche Ports und Server die DatagramSocket-Objekte gebunden sind. Für den Client ist dies nicht so interessant, da er häufig als Absender einen beliebigen Port nutzen kann. Läuft ein Paket zum Server, kann dieser immer anhand der gespeicherten Adresse eine Rückantwort schicken. Wir werden das auch an den Beispielen sehen, in denen wir erst ein leeres Paket als Anfrage schicken und dann den Server über uns informieren. Einen beliebigen Port nimmt der erste Konstruktor, da dieser bedeutet, dass jeder Port zur Kommunikation in Richtung Server verwendet werden kann. Nur ein Client muss wissen, auf welchem Port ein Server seinen Dienst bereitstellt. Die Port-Adresse auf der Client-Seite festzusetzen, ist nur dann wichtig, wenn hinter einer Firewall operiert wird.

Abbildung
Hier klicken, um das Bild zu Vergrößern


Galileo Computing

16.13.2 Datagramme und die Klasse DatagramPacket  downtop

Zum Senden und Empfangen wird in beiden Fällen die Klasse DatagramPacket benutzt. Hier sind zwei Fälle zu unterscheiden, die verschiedene Konstruktoren implementieren.

Ein Paket zum Empfang vorbereiten

Wenn wir Daten empfangen, müssen wir nur ein DatagramPacket-Objekt anlegen und den Speicherplatz angeben, an dem die Daten abgelegt werden sollen. Das Feld ist so etwas wie ein Platzhalter. Die folgenden Zeilen reichen für einen Server, der am Port des Duftes 4711 horcht:

byte[] data = new byte[1024];
DatagramSocket socket = new DatagramSocket( 4711 );
DatagramPacket packet = new DatagramPacket( datadata.length );
socket.receive( packet );

Abbildung
Hier klicken, um das Bild zu Vergrößern


Galileo Computing

16.13.3 Auf ein hereinkommendes Paket warten  downtop

Wenn wir empfangen wollen, müssen wir warten, bis ein Paket eintrifft. Das geschieht mit der DatagramSocket-Methode receive(DatagramPacket). Die Methode ist vergleichbar mit der accept()-Methode der Klasse ServerSocket, nur dass accept() ein Socket-Objekt zurückgibt und receive() die Daten in dem als Argument übergebenen DatagramPacket ablegt. Mit den Methoden getPort() und getAddress() können wir herausfinden, woher das Paket stammt, wer also der Sender war. Mit getData() bekommen wir die Daten als Bytefeld, und getLength() liefert die Länge. Ist das empfangene Paket größer als unser Puffer, wird das Feld nur bis zur maximalen Größe gefüllt.

Das folgende Programm implementiert einen horchenden Server, der noch nicht auf Pakete antwortet. Es empfängt still und gibt die Informationen über das empfangene Paket aus.

Listing 16.18   com/javatutor/insel/net/udp/UDPServer.java

package com.javatutor.insel.net.udp;
import java.io.IOException;
import java.net.*;
public class UDPServer
{
  public static void main( String[] args ) throws IOException
  {
    DatagramSocket socket = new DatagramSocket( 4711 );
    while ( true )
    {
      // Auf Anfrage warten
      DatagramPacket packet = new DatagramPacket( new byte[1024]1024 );
      socket.receive( packet );
      // Empfänger auslesen
      InetAddress address = packet.getAddress();
      int         port    = packet.getPort();
      int         len     = packet.getLength();
      byte[]      data    = packet.getData();
      System.out.println( "Anfrage von " + address +
                          " vom Port " + port +
                          " Länge " + len +
                          "\n" + new String( data0len ) );
    }
  }
}

Galileo Computing

16.13.4 Ein Paket zum Senden vorbereiten  downtop

Wenn wir ein Paket senden wollen, müssen wir einem DatagramPacket auch noch mitteilen, wohin die Reise geht, das heißt: der Port und die IP-Adresse des entfernten Rechners sind anzugeben. Der Empfänger wird durch ein InetAddress-Objekt repräsentiert, der Konstruktor ist leider nicht mit einem String-Objekt überladen, was sicherlich nützlich wäre. Es gibt aber einen speziellen Konstruktor, der die Inet-Adresse und den Port direkt entgegennimmt.

Folgende Zeilen erzeugen ein DatagramPacket-Objekt mit einem Bytefeld für den Empfänger und senden es gleich:

InetAddress ia;
ia = InetAddress.getByName( "www.reich-und-schoen-waere.toll" );
int port = 4711;
String s = "Wer andere links liegen lässt, steht rechts.";
byte[] data = s.getBytes();
packet = new DatagramPacket( datadata.lengthiaport );
DatagramSocket toSocket = new DatagramSocket();
toSocket.send( packet );

Zusätzlich zum Bytefeld geben wir die Anzahl der Byte an, die gesendet werden sollen. Dies erinnert an C-Stil und ist eigentlich unnötig, weil in Java das Bytefeld in der Länge abgefragt werden kann und hier fast immer data.length passt. Doch so sind wir etwas flexibler. Wenn wir Strings übermitteln, was häufig vorkommt, bietet sich getBytes() zur Umwandlung an. Eine andere Möglichkeit, eine Zeichenkette in ein Bytefeld umzuwandeln, ist folgende:

String s = "Gebt einem Brandstifter nie euren Zündschlüssel."
byte[] data = new byte [ s.length() ];
s.getBytes( 0data.lengthdata0 );

Galileo Computing

16.13.5 Methoden der Klasse DatagramPacket  downtop

Das DatagramPaket ist auch nachträglich veränderbar und kann mit Methoden angepasst und auch ausgelesen werden:


class java.net.  DatagramSocket  

gp  InetAddress getAddress() Hier müssen wir unterscheiden, ob das Paket hereinkommend oder ausgehend ist. Für ein hereinkommendes DatagramPacket liefert die Methode die Adresse, von der das Paket kam. Für ein ausgehendes Paket liefert getAddress() die Adresse, an die das Paket geht.
gp  public int getPort() Für ein hereinkommendes Paket liefert es die Port-Nummer vom Sender. Für ein ausgehendes Paket liefert getPort() den Port, an den das Datagram geht.

Das folgende Programm zeigt ein zu sendendes Paket, und wir können die abgelegten Informationen wieder auslesen.

Listing 16.19   com/javatutor/insel/net/udp/DatagramPacketEntries.java

package com.javatutor.insel.net.udp;
import java.net.*;
import java.util.*;
public class DatagramPacketEntries
{
  public static void main( String[] args ) throws Exception
  {
    byte[] data = new Date().toString().getBytes();
    InetAddress ia    = InetAddress.getByName( "localhost" );
    int         port = 7;
    DatagramPacket p = new DatagramPacket( datadata.lengthiaport );
    System.out.println( "Paket addressiert an " + p.getAddress()
                        + " an Port " + p.getPort() + "\n"
                        + "Mit " + p.getLength() + " Byte: "
                        + new String(p.getData()) );
  }
}

Galileo Computing

16.13.6 Das Paket senden  toptop

Zum Senden eines DatagramPacket dient die DatagramSocket-Methode send(DatagramPacket). Sie schickt das Datagram an die im DatagramPacket enthaltene Port-Nummer und -Adresse. Im oberen Beispiel hatten wir diese Informationen einmal ausgelesen. Die Reihenfolge für Sendevorgänge ist also immer die gleiche: Erst ein Datagram-Socket mit einem Standard-Konstruktor, dann das DatagramPaket-Objekt mit dem Port und der Inet-Adresse des Empfängers erzeugen, dann schickt send() das Paket auf die Reise. Wir sehen im folgenden Beispiel einen Client, der sich mit einem Server verbindet und einfach die Uhrzeit abschickt. Dies dient der Vorbereitung auf einen eigenen UDP-Zeit-Server.

Listing 16.20   com/javatutor/insel/net/udp/UDPClient.java

package com.javatutor.insel.net.udp;
import java.io.IOException;
import java.net.*;
import java.util.*;
class UDPClient
{
  public static void main( String[] args ) throws IOExceptionInterruptedException
  {
    InetAddress ia = InetAddress.getByName( "localhost" );
    while ( true )
    {
      String s = new Date().toString();
      byte[] raw = s.getBytes();
      DatagramPacket packet = new DatagramPacket( rawraw.lengthia4711 );
      DatagramSocket dSocket = new DatagramSocket();
      dSocket.send( packet );
      System.out.println( "Weg is' es" );
      Thread.sleep( 1000 );
    }
  }
}
 << zurück




Copyright © Galileo Press GmbH 2005
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de