Bearbeiten von „ServerSocket und Socket - Netzwerkgrundlagen“

=Theorie, ServerSocket = Socket?=
Ein Socket stellt einen logischen 'Sockel' für TCP- oder UDP-Netzwerkkommunikation dar. Hier wird nur TCP-Kommunikation behandelt.

TCP-Kommuniktion basiert auf sogenannten Ports, Ports benutzen Betriebssysteme um mehrere Verbindungen auseinanderhalten zu können. Jeder Port kann nur für eine Verbindung gleichzeitig benutzt werden.
 Merke: Ports sind wie Sockets nur logische Konstrukte, in der Hardware sind weder Sockets noch Ports umgesetzt, beides sind lediglich Funktionen die das Betriebssystem zur Verfügung stellt.

Ein Socket kann benutzt werden um von einem lokalen Port eine Verbindung zu einem entferntem Port (dieser kann auf jedem über das Netzwerk erreichbaren Rechner sein, auch dem eigenen!) zu benutzen. Dazu muss ein neuer Socket mindestens mit zwei Angaben konstruiert werden: Zielrechner und Zielport. Der Quellport (auf dem eigenen Rechner, von dem die Kommunikation abgeht) wird vom Betriebssystem automatisch gewählt.

Es ist also nicht möglich auf eine neue Verbindung zu 'warten'. Diese Aufgabe übernimmt ein sog. ServerSocket, welcher automatisch an einen (anzugebenen) Port gebunden wird, auch hier gilt, nur ein Socket/Verbindung pro Port. Der ServerSocket selbst ist für keine wirkliche Kommunikation zuständig, er ist lediglich dafür zuständig neue Verbindungen anzunehmen. Diese werden dann automatisch auf einen neuen Port "umgeleitet" um den Server-Port wieder für neue Verbindungen freizumachen. 

 Zusammenfassung: Netzwerkkommunikation passiert über Ports die über Sockets angesprochen werden. Um auf neue Verbindungen zu warten wird ein ServerSocket benutzt, der für jede Verbindung einen neuen Socket liefert.



=Socketverbindungen=
Eine simple Verbindung zu einem anderen Rechner (hier allerdings der lokale Host) kann so aussehen:
<code=java>
[...]

// socket auf localhost port 1234 konstruieren
Socket s = new Socket("localhost",1234);

// etwas über den socket versenden
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
out.write("Hello World");

// zeilenumbruch senden
out.newLine();
out.flush();
</code=java>

Soweit noch ganz einfach, um den OutputStream den der Socket auf Anfrage liefert (über den auch sämtliche Kommunikation 'in' den Socket läuft) wird ein BufferedWriter konstruiert, damit wir ganze Zeilen senden können.

Zu beachten sind zwei Dinge:
*Damit auf der anderen Seite auch das Ende der Zeile erkannt werden kann, müssen wir explizit einen Zeilenumbruch mitschicken!
*Wenn Streams oder Writer mit Puffer (Buffer) benutzt werden, dann sollte, sofern es gewünscht wird das der gerade übergebene Text sofort gesendet wird _immer_ die Methode flush() aufgerufen werden, die alles was gerade im Puffer ist weiterleitet. Unter Umständen passiert sonst eine ganze Zeit lang keine Kommunikation da der Puffer noch nicht voll ist und so nicht weitergeleitet wird.

Der Socket kann natürlich nicht nur mit ausgehenden Daten umgehen, sondern auch mit eingehenden:
<code=java>
// BufferedReader konstruieren
BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));

// eine zeile lesen
String text = in.readLine()

// und ausgeben
System.out.print("Received: ");
System.out.println(text); 

// am ende schliessen wir alle offenen Reader und Writer, der Socket wird dabei automatisch geschlossen
out.close();
in.close();
</code=java>

Hier ist eine bereits angesprochene Sache zu beachten:
*readLine() wartet (blockiert) so lange, bis ein Zeilenumbruch empfangen wird! Wird keiner gesendet, wartet die Methode ewig!



=Socket-Server=
Auf der anderen Seite brauchen wir nun natürlich einen Server, der mit unserem kleinen Client 'reden' kann. Dazu brauchen wir einen ServerSocket der sich an den entsprechenden Port bindet um dort auf Clients zu warten.
<code=java>
[...]

// Server starten
ServerSocket server = new ServerSocket(1234);

// warten auf eine neue Verbindung
Socket s = server.accept();

// neue Verbindung ist da, wir lesen einfach aus, 
// was sie uns so schickt und schicken dann alles in grossbuchstaben wieder zurück
BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
String text = in.readLine();
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
out.write(text.toUpperCase());
out.newLine();
out.flush();

// aufräumen
out.close();
in.close();
server.close();
</code=java>

An sich kein Problem, bis auf den ServerSocket tut das Programm genau dasselbe wie der Client. 

Die Methode accept() blockiert das Programm solange bis eine neue Verbindung ankommt. Für diese Verbindung wird dann ein neuer Socket zurückgegeben der genauso wie ein normaler Socket funktioniert. Zu beachten ist, das accept() immer nur _eine_ Verbindung liefert, soll der Server auf weitere Verbindungen warten, so muss accept() wieder aufgerufen werden!

Zu bedenken ist auch, das in.readLine() zwar eine Zeile liest, der String aber _keinen_ Zeilenumbruch am Ende besitzt (also wieder explizit einen senden!)



=Threads und Server=
Es wird schnell klar das obiger Server nicht recht tauglich ist:

*Es wird nur eine Verbindung angenommen, danach beendet sich der Server
*Selbst wenn, zB. über eine while(true)-Schleife accept() wieder aufgerufen werden sollte, ist der Server für die Dauer der Bearbeitung einer Verbindung nicht erreichbar.

Sinnvoller wäre es, wenn der Server sich nur um neue Verbindungen kümmern würde und die Arbeit die eine eigentliche Verbindung macht an einen nebenläufigen Thread abgeben könnte. 

'''Server'''
<code=java>
[...]

// Server aufbauen
ServerSocket server = new ServerSocket(1234);
Socket s;

while(true) {

// Auf verbindung warten
s = server.accept();

// kommunikation an einen nebenläufigen Thread abgeben
ServerThread t = new ServerThread(s);
t.start();

// und wieder auf neue Verbindungen warten

}
</code=java>

ServerThread
<code=java>
public class ServerThread extends Thread {
   private Socket s;
   public ServerThread(Socket s) {
      this.s = s;
   }
   public void run() {

      // lesen
      BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
      String text = in.readLine();

      // schreiben
      BufferedWriter out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
      out.write(text.toUpperCase());
      out.newLine();
      out.flush();

      // aufräumen
      out.close();
      in.close();
   }
}
</code=java>

Dies ist natürlich nur ein einfaches Konzept, echte Socketverbindungen können zB. über längere Zeit aufbleiben (damit sich die Threads auch lohnen), aber es macht deutlich wie ein Server mit nebenläufigen Threads funktionieren kann.