Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Generics, innere Klassen
10 Die Klassenbibliothek
11 Threads und nebenläufige Programmierung
12 Datenstrukturen und Algorithmen
13 Raum und Zeit
14 Dateien und Datenströme
15 Die eXtensible Markup Language (XML)
16 Grafische Oberflächen mit Swing
17 Grafikprogrammierung
18 Netzwerkprogrammierung
19 Verteilte Programmierung mit RMI und Web–Services
20 JavaServer Pages und Servlets
21 Applets
22 Midlets und die Java ME
23 Datenbankmanagement mit JDBC
24 Reflection und Annotationen
25 Logging und Monitoring
26 Sicherheitskonzepte
27 Java Native Interface (JNI)
28 Dienstprogramme für die Java-Umgebung
Stichwort
Download: - ZIP, ca. 14,1 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> / Java-Insel | vor >>
Java ist auch eine Insel (8. Auflage) von Christian Ullenboom Programmieren mit der Java Standard Edition Version 6
Java ist auch eine Insel (8. Aufl.) 8., aktual. Auflage, geb., mit DVD 1.475 S., 49,90 Euro Galileo Computing ISBN 978-3-8362-1371-4 |
| 18 Netzwerkprogrammierung
|  | 18.1 Grundlegende Begriffe
|  |  | 18.1.1 Internet-Standards und RFC
|  | 18.2 URI und URL
|  |  | 18.2.1 URI
|  |  | 18.2.2 Die Klasse URL
|  |  | 18.2.3 Informationen über eine URL
|  |  | 18.2.4 Der Zugriff auf die Daten über die Klasse URL
|  |  | 18.2.5 Verbindungen durch einen Proxy-Server
|  | 18.3 Die Klasse URLConnection
|  |  | 18.3.1 Methoden und Anwendung von URLConnection
|  |  | 18.3.2 Protokoll- und Content-Handler
|  |  | 18.3.3 Im Detail: vom URL zur URLConnection
|  |  | 18.3.4 Der Protokoll-Handler für Jar-Dateien
|  |  | 18.3.5 Basic Authentication/Proxy-Authentifizierung
|  | 18.4 Mit GET und POST Daten übergeben
|  |  | 18.4.1 Kodieren der Parameter für Serverprogramme
|  |  | 18.4.2 Eine Suchmaschine ansprechen
|  | 18.5 Host- und IP-Adressen
|  |  | 18.5.1 Lebt der Rechner?
|  |  | 18.5.2 IP-Adresse des lokalen Hosts
|  |  | 18.5.3 Das Netz ist Klasse …
|  | 18.6 NetworkInterface
|  | 18.7 Mit dem Socket zum Server
|  |  | 18.7.1 Das Netzwerk ist der Computer
|  |  | 18.7.2 Sockets
|  |  | 18.7.3 Eine Verbindung zum Server aufbauen
|  |  | 18.7.4 Server unter Spannung: die Ströme
|  |  | 18.7.5 Die Verbindung wieder abbauen
|  |  | 18.7.6 Informationen über den Socket
|  |  | 18.7.7 Reine Verbindungsdaten über SocketAddress
|  | 18.8 Client-Server-Kommunikation
|  |  | 18.8.1 Warten auf Verbindungen
|  |  | 18.8.2 Ein Multiplikationsserver
|  |  | 18.8.3 Blockierendes Lesen
|  |  | 18.8.4 Von außen erreichbar sein
|  | 18.9 Apache Jakarta Commons HttpClient und Net
|  |  | 18.9.1 Jakarta Commons HttpClient
|  |  | 18.9.2 Jakarta Commons Net
|  | 18.10 Arbeitsweise eines Webservers
|  |  | 18.10.1 Das Hypertext Transfer Protocol (HTTP)
|  |  | 18.10.2 Anfragen an den Server
|  |  | 18.10.3 Die Antworten vom Server
|  |  | 18.10.4 Webserver mit com.sun.net.httpserver.HttpServer
|  | 18.11 Datagram-Sockets
|  |  | 18.11.1 Die Klasse DatagramSocket
|  |  | 18.11.2 Datagramme und die Klasse DatagramPacket
|  |  | 18.11.3 Auf ein hereinkommendes Paket warten
|  |  | 18.11.4 Ein Paket zum Senden vorbereiten
|  |  | 18.11.5 Methoden der Klasse DatagramPacket
|  |  | 18.11.6 Das Paket senden
|  | 18.12 E-Mail
|  |  | 18.12.1 Wie eine E-Mail um die Welt geht
|  |  | 18.12.2 Das Simple Mail Transfer Protocol und RFC 822
|  |  | 18.12.3 POP (Post Office Protocol)
|  |  | 18.12.4 Die JavaMail API
|  |  | 18.12.5 E-Mails mittels POP3 abrufen
|  |  | 18.12.6 E-Mails versenden
|  |  | 18.12.7 Ereignisse und Suchen
|  | 18.13 Tiefer liegende Netzwerkeigenschaften
|  |  | 18.13.1 Internet Control Message Protocol (ICMP)
|  |  | 18.13.2 MAC-Adresse
|  | 18.14 Zum Weiterlesen
## 18.11 Datagram-Sockets 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). Dieses 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 kennenlernen, das 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 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 nutzt, 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 Bytes 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 Bytes 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 können schneller sein. 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. Bei Diensten mit Quality of Service (QoS) könnte der Router aber TCP-Pakete bevorzugen und bei drohendem Vermittlungseinbruch UDP-Pakete verwerfen. 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 File System (NFS). NFS ist so ausgelegt, dass verloren gegangene Pakete wiederbesorgt 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 existiert 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 voneinander. Bei UDP verwenden beide die Klasse DatagramSocket, die für eine eingehende und auch ausgehende Verbindung steht.

Tabelle 18.3 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
### 18.11.1 Die Klasse DatagramSocket 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
DatagramSocket() throws SocketException DatagramSocket( int port ) throws SocketException DatagramSocket( int port, InetAddress laddr ) throws SocketException DatagramSocket( SocketAddress bindaddr ) throws SocketException 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 Clientseite festzusetzen, ist nur dann wichtig, wenn hinter einer Firewall operiert wird. Hier klicken, um das Bild zu vergrößern ### 18.11.2 Datagramme und die Klasse DatagramPacket 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( data, data.length );
    socket.receive( packet );
Hier klicken, um das Bild zu vergrößern ### 18.11.3 Auf ein hereinkommendes Paket warten 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 Byte-Feld, 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 18.17 com/tutego/insel/net/udp/UDPServer.java
    package com.tutego.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.printf( "Anfrage von %s vom Port %d mit der Länge %d:%n%s%n",
                             address, port, len, new String( data, 0, len ) );
        }
      }
    }
### 18.11.4 Ein Paket zum Senden vorbereiten 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 Byte-Feld 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( data, data.length, ia, port );
    DatagramSocket toSocket = new DatagramSocket();
    toSocket.send( packet );
Zusätzlich zum Byte-Feld geben wir die Anzahl der Bytes an, die gesendet werden sollen. Dies erinnert an C-Stil und ist eigentlich unnötig, weil in Java das Byte-Feld 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 Byte-Feld umzuwandeln, ist folgende:
    String s = "Gebt einem Brandstifter nie euren Zündschlüssel."
    byte[] data = new byte [ s.length() ];
    s.getBytes( 0, data.length, data, 0 );
### 18.11.5 Methoden der Klasse DatagramPacket Das DatagramPacket ist auch nachträglich veränderbar und kann mit Methoden angepasst und auch ausgelesen werden. Das folgende Programm zeigt ein zu sendendes Paket, und wir können die abgelegten Informationen wieder auslesen. Listing 18.18 com/tutego/insel/net/udp/DatagramPacketEntries.java
    package com.tutego.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( data, data.length, ia, port );

        System.out.printf( "Paket adressiert an %s an Port %d mit %d Byte:%n%s%n",
                           p.getAddress(), p.getPort(), p.getLength(),
                           new String(p.getData()) );
      }
    }
    class java.net.DatagramSocket
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. public int getPort() Liefert für ein hereinkommendes Paket die Port-Nummer vom Sender. Für ein ausgehendes Paket liefert getPort() den Port, an den das Datagramm geht. ### 18.11.6 Das Paket senden Zum Senden eines DatagramPacket dient die DatagramSocket-Methode send(Datagram-Packet). Sie schickt das Datagramm 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 aufbauen, dann das DatagramPacket-Objekt mit dem Port und der Inet-Adresse des Empfängers erzeugen, und 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 18.19 com/tutego/insel/net/udp/UDPClient.java
    package com.tutego.insel.net.udp;

    import java.io.IOException;
    import java.net.*;
    import java.util.*;

    class UDPClient
    {
      public static void main( String[] args ) throws IOException,
                                              InterruptedException
      {
        InetAddress ia = InetAddress.getByName( "localhost" );

        while ( true )
        {
          String s = new Date().toString();
          byte[] raw = s.getBytes();

          DatagramPacket packet = new DatagramPacket( raw, raw.length, ia, 4711 );

          DatagramSocket dSocket = new DatagramSocket();

          dSocket.send( packet );

          System.out.println( "Weg is' es" );

          Thread.sleep( 1000 );
        }
      }
    }
### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück | <top> | vor >>
Zum Katalog
Java ist auch eine Insel Jetzt bestellen
Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen? Ihre Meinung
Tipp
| Coding for Fun
Buchempfehlungen
| Objektorientierte Programmierung
| Einstieg in Eclipse 3.4
| Java 6 lernen mit Eclipse
| NetBeans Platform 6
| Java und XML
| Visual C# 2008
| IT-Handbuch für Fachinformatiker
| C++ von A bis Z
Shopping
Versandkostenfrei bestellen in Deutschland und Österreich Info

Copyright © Galileo Press 2009
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, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de