16.9 Client/Server-Kommunikation

Bevor wir nun weitere Dienste untersuchen, wollen wir einen kleinen Server programmieren. Server bauen keine eigene Verbindung auf, sondern horchen an ihrem zugewiesenen Port auf Eingaben und Anfragen. Ein Server wird durch die Klasse ServerSocket repräsentiert. Da wir einen Server selber programmieren wollen, erzeugen wir ein ServerSocket-Objekt mit einem Konstruktor, dem wir einen Port als Parameter übergeben.

ServerSocket serverSocket = new ServerSocket( 1234 );

Natürlich müssen wir unserem Client eine noch nicht zugewiesene Port-Adresse zuteilen, andernfalls ist uns eine IOException sicher. Das häufig verwendete 1234 ist zwar schon vom Infoseek Search Agent (search-agent) zugewiesen, sollte aber dennoch nicht zu Problemen führen, da er auf dem eigenen Rechner gewöhnlich nicht installiert ist. Bei Unix-Systemen können nur Root-Besitzer Ports unter 1024 nutzen. Unter dem herkömmlichen Windows ist das egal.

Hier klicken, um das Bild zu Vergrößern

16.9.1 Warten auf Verbindungen

Nachdem der Socket eingerichtet ist, kann er auf hereinkommende Meldungen reagieren. Mit der blockierenden Methode accept() der ServerSocket-Klasse nehmen wir genau eine wartende Verbindung an:

Socket server = serverSocket.accept();

Nun können wir mit dem zurückgegebenen Client-Socket genau so verfahren wie mit dem schon programmierten Client. Das heißt, wir öffnen Ein- und Ausgabekanäle und kommunizieren. In der Regel wird ein Thread den Client-Socket annehmen, damit der Server schnell wieder verfügbar ist und neue Verbindungen annehmen und verarbeiten kann.

Wichtig bleibt zu bemerken, dass die Konversation nicht über den Server-Socket selbst läuft. Dieser ist immer noch aktiv und horcht auf eingehende Anfragen. Die accept()-Methode sitzt daher oft in einer Endlosschleife und erzeugt für jeden Hörer einen Thread. Die Schritte, die also jeder Server vollzieht, sind folgende:

Der Server wartet auch nicht ewig

Soll der Server nur eine gewisse Zeit auf einkommende Nachrichten warten, so lässt sich ein Timeout einstellen. Dazu ist der Methode setSoTimeout() die Anzahl der Millisekunden zu übergeben. Nimmt der Server dann keine Fragen entgegen, bricht die Verarbeitung mit einer InterruptedIOException ab. Diese Exception gilt für alle Ein- und Ausgabe-Operationen und ist daher auch eine Ausnahme, die nicht im Net-Paket, sondern im IO-Paket deklariert ist.

ServerSocket server = new ServerSocket( port );
// Timeout nach 1 Minute
server.setSoTimeout( 60000 );
try {
  Socket socket = server.accept();
} catch ( InterruptedIOException e ) {
  System.err.println( "Timeout after one minute" );
}

16.9.2 Ein Multiplikations-Server

Der erste Server, den wir programmieren wollen, soll zwei Zahlen multiplizieren. Dazu reichen wir ihm im Eingabestrom zwei Zahlen, die er dann multipliziert und zurückschreibt.

Listing 16.13 MulServer.java

import java.net.*;
import java.io.*;
class MulServer
{
  public static void main( String args[] ) throws IOException
  {
    Socket client = server.accept();
    InputStream in = client.getInputStream();
    OutputStream out = client.getOutputStream();
    int start = in.read();
    int end = in.read();
    int result = start * end;
    out.write( result );
  }
}

Wir starten den Server auf Port 3141. Nun geht es auf der anderen Seite mit dem Client weiter:

Listing 16.14 MulClient.java

import java.net.*;
import java.io.*;
class MulClient
{
  public static void main( String args[] ) throws IOException
  {
    Socket server = new Socket ( "localhost", 3141 );
    
    InputStream in = server.getInputStream();
    OutputStream out = server.getOutputStream();
    
    out.write( 4 );
    out.write( 9 );
    
    int result = in.read();
    System.out.println( result );
    
    server.close();
  }
}

Natürlich ist der Server in der Funktionalität beschränkt, da nur Bytes übertragen werden. So kann das Ergebnis nicht größer als 127 werden, denn ansonsten würde es falsch übermittelt. Dennoch lässt sich das Programm leicht als Ausgangspunkt für einige Server erweitern.

Ein anderer Punkt ist, dass Server im Allgemeinen multithreaded ausgelegt sind, damit sie mehrere Anfragen gleichzeitig ausführen können. Noch besser ist, die Threads in einen Thread-Pool zu legen, denn ein neuer Thread pro Anfrager ist eine teure Tat.