Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
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?

Spacer
<< zurück
Java ist auch eine Insel (8. Auflage) von Christian Ullenboom
Programmieren mit der Java Standard Edition Version 6
Buch: Java ist auch eine Insel (8. Auflage)

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
Pfeil 18 Netzwerkprogrammierung
Pfeil 18.1 Grundlegende Begriffe
Pfeil 18.1.1 Internet-Standards und RFC
Pfeil 18.2 URI und URL
Pfeil 18.2.1 URI
Pfeil 18.2.2 Die Klasse URL
Pfeil 18.2.3 Informationen über eine URL
Pfeil 18.2.4 Der Zugriff auf die Daten über die Klasse URL
Pfeil 18.2.5 Verbindungen durch einen Proxy-Server
Pfeil 18.3 Die Klasse URLConnection
Pfeil 18.3.1 Methoden und Anwendung von URLConnection
Pfeil 18.3.2 Protokoll- und Content-Handler
Pfeil 18.3.3 Im Detail: vom URL zur URLConnection
Pfeil 18.3.4 Der Protokoll-Handler für Jar-Dateien
Pfeil 18.3.5 Basic Authentication/Proxy-Authentifizierung
Pfeil 18.4 Mit GET und POST Daten übergeben
Pfeil 18.4.1 Kodieren der Parameter für Serverprogramme
Pfeil 18.4.2 Eine Suchmaschine ansprechen
Pfeil 18.5 Host- und IP-Adressen
Pfeil 18.5.1 Lebt der Rechner?
Pfeil 18.5.2 IP-Adresse des lokalen Hosts
Pfeil 18.5.3 Das Netz ist Klasse …
Pfeil 18.6 NetworkInterface
Pfeil 18.7 Mit dem Socket zum Server
Pfeil 18.7.1 Das Netzwerk ist der Computer
Pfeil 18.7.2 Sockets
Pfeil 18.7.3 Eine Verbindung zum Server aufbauen
Pfeil 18.7.4 Server unter Spannung: die Ströme
Pfeil 18.7.5 Die Verbindung wieder abbauen
Pfeil 18.7.6 Informationen über den Socket
Pfeil 18.7.7 Reine Verbindungsdaten über SocketAddress
Pfeil 18.8 Client-Server-Kommunikation
Pfeil 18.8.1 Warten auf Verbindungen
Pfeil 18.8.2 Ein Multiplikationsserver
Pfeil 18.8.3 Blockierendes Lesen
Pfeil 18.8.4 Von außen erreichbar sein
Pfeil 18.9 Apache Jakarta Commons HttpClient und Net
Pfeil 18.9.1 Jakarta Commons HttpClient
Pfeil 18.9.2 Jakarta Commons Net
Pfeil 18.10 Arbeitsweise eines Webservers
Pfeil 18.10.1 Das Hypertext Transfer Protocol (HTTP)
Pfeil 18.10.2 Anfragen an den Server
Pfeil 18.10.3 Die Antworten vom Server
Pfeil 18.10.4 Webserver mit com.sun.net.httpserver.HttpServer
Pfeil 18.11 Datagram-Sockets
Pfeil 18.11.1 Die Klasse DatagramSocket
Pfeil 18.11.2 Datagramme und die Klasse DatagramPacket
Pfeil 18.11.3 Auf ein hereinkommendes Paket warten
Pfeil 18.11.4 Ein Paket zum Senden vorbereiten
Pfeil 18.11.5 Methoden der Klasse DatagramPacket
Pfeil 18.11.6 Das Paket senden
Pfeil 18.12 E-Mail
Pfeil 18.12.1 Wie eine E-Mail um die Welt geht
Pfeil 18.12.2 Das Simple Mail Transfer Protocol und RFC 822
Pfeil 18.12.3 POP (Post Office Protocol)
Pfeil 18.12.4 Die JavaMail API
Pfeil 18.12.5 E-Mails mittels POP3 abrufen
Pfeil 18.12.6 E-Mails versenden
Pfeil 18.12.7 Ereignisse und Suchen
Pfeil 18.13 Tiefer liegende Netzwerkeigenschaften
Pfeil 18.13.1 Internet Control Message Protocol (ICMP)
Pfeil 18.13.2 MAC-Adresse
Pfeil 18.14 Zum Weiterlesen


Galileo Computing - Zum Seitenanfang

18.11 Datagram-Sockets Zur nächsten ÜberschriftZur vorigen Überschrift

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



Galileo Computing - Zum Seitenanfang

18.11.1 Die Klasse DatagramSocket Zur nächsten ÜberschriftZur vorigen Überschrift

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.


Galileo Computing - Zum Seitenanfang

18.11.2 Datagramme und die Klasse DatagramPacket Zur nächsten ÜberschriftZur vorigen Überschrift

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 );

Galileo Computing - Zum Seitenanfang

18.11.3 Auf ein hereinkommendes Paket warten Zur nächsten ÜberschriftZur vorigen Überschrift

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 ) ); 
    } 
  } 
}

Galileo Computing - Zum Seitenanfang

18.11.4 Ein Paket zum Senden vorbereiten Zur nächsten ÜberschriftZur vorigen Überschrift

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 );

Galileo Computing - Zum Seitenanfang

18.11.5 Methoden der Klasse DatagramPacket Zur nächsten ÜberschriftZur vorigen Überschrift

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.

Galileo Computing - Zum Seitenanfang

18.11.6 Das Paket senden topZur vorigen Überschrift

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.






<< zurück
  Zum Katalog
Zum Katalog: Java ist auch eine Insel





Java ist auch eine Insel
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Tipp
Zum Katalog: Coding for Fun





 Coding for Fun


 Buchempfehlungen
Zum Katalog: Objektorientierte Programmierung





 Objektorientierte
 Programmierung


Zum Katalog: Einstieg in Eclipse 3.4






 Einstieg in
 Eclipse 3.4


Zum Katalog: Java 6 lernen mit Eclipse






 Java 6 lernen
 mit Eclipse


Zum Katalog: NetBeans Platform 6






 NetBeans
 Platform 6


Zum Katalog: Java und XML






 Java und XML


Zum Katalog: Visual C# 2008






 Visual C# 2008


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


Zum Katalog: C++ von A bis Z






 C++ von A bis Z


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




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