Beispiel: Socket-Grundlagen

Serverseite

package de.fhw.swtprojekt.knauf.simplesocket;

import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class SimpleServer
{
  public static void main(String[] args)
  {
    try
    {
      //Warte auf Anfragen auf Port 13000:
      ServerSocket serverSocket = new ServerSocket(13000);
  
      //Eine einzige Anfrage entgegennehmen:
      Socket clientSocket = serverSocket.accept();
  
      //Die Rückgabe in einen Ausgabestream schreiben:
      PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
      //Senden eines Newline sorgt dafür, dass der PrintWriter die Ausgabe "abschickt". Alternativ müsste "flush" aufgerufen werden.
      out.println("Serverantwort");
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }
 }

Client

package de.fhw.swtprojekt.knauf.simplesocket;

import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.net.Socket;

public class SimpleClient
{
  public static void main(String[] args)
  {
    try
    {
      //Verbindung zu Port 13000 auf localhost aufbauen:
      Socket socket = new Socket ("localhost", 13000);

      //Eine Zeile lesen:
      BufferedReader in = new BufferedReader(new InputStreamReader(socketServer.getInputStream()));
      String serverResponse = in.readLine();
      System.out.println("Server-Antwort: " + serverResponse);
  
      //Socket dichtmachen:
      socket.close();
    }
    catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }

Multiple Clients versorgen

package de.fhw.swtprojekt.knauf;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Server-Seite des simplen Textverteiler-Servers.
 * 
 * @author Wolfgang Knauf
 * 
 */
public class TextServer
{

  /**Server lauscht auf Port 13000 und nimmt in einer Endlosschleife Antworten entgegen.
   * 
   * @param args
   */
  public static void main(String[] args)
  {
    ServerSocket serverSocket = null;

    //An Port 13000 binden:
    try
    {
      serverSocket = new ServerSocket(13000);
    }
    catch (IOException e)
    {
      System.out.println("Binden an Port  13000 schlug fehl: " + e.getMessage());
      System.exit(-1);
    }
    
    //In einer Endlosschleife auf eingehende Anfragen warten.
    while (true)
    {
      try
      {
        //Blocken, bis eine Anfrage kommt:
        System.out.println ("ServerSocket - accepting");
        Socket clientSocket = serverSocket.accept();
        
        //Wenn die Anfrage da ist, dann wird ein Thread gestartet, der 
        //die weitere Verarbeitung übernimmt.
        System.out.println ("ServerSocket - accept done");
        Thread threadHandler = new Thread(new TextServerHandler(clientSocket) );
        threadHandler.start();
		
		System.out.println ("ServerSocket - Thread started, next client please...");
      }
      catch (IOException e)
      {
        System.out.println("'accept' auf Port 13000 fehlgeschlagen");
        System.exit(-1);
      }
      
    }
  }
} 

package de.fhw.swtprojekt.knauf;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * Diese Klasse übernimmt die Kommunikation zwischen einem einzelnen Client und dem Server.
 * Sie nimmt Strings entgegen und liefert das "toUpper" zurück.
 * 
 * @author Wolfgang Knauf
 * 
 */
public class TextServerHandler implements Runnable
{
  /**
   * Dies ist die Client-Verbindung.
   * 
   */
  private Socket clientSocket;

  /**
   * Konstruktor, dem der Client-Socket übergeben wird.
   * 
   * @param _clientSocket Socket-Verbindung zum Client.
   */
  public TextServerHandler(Socket _clientSocket)
  {
    this.clientSocket = _clientSocket;
  }

  /**Thread wird ausgeführt: alle Daten, die der Client schickt, in Upper Case konvertieren
   * und zurückschicken. 
   * 
   */
  @Override
  public void run()
  {
    try
    {
      System.out.println("Thread " + Thread.currentThread().getId() + " für Clientanfrage gestartet !");
      // Eingabe-Reader und Ausgabe-Writer erzeugen.
      // Es wird hier nur mit Text gearbeitet und zeilenweise eingelesen bzw. geschrieben.
      PrintWriter out = new PrintWriter(this.clientSocket.getOutputStream(), true);
      BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

      // In einer Endlosschleife auf Eingaben horchen bis die Verbindung beendet wird
      // und ein "readLine" dadurch nichts mehr zurückliefert. 
      String strInput = null;
      System.out.println ("Thread " + Thread.currentThread().getId() + " für Clientanfrage wartet auf Antwort...");
      while ((strInput = in.readLine()) != null)
      {
        System.out.println("Thread " + Thread.currentThread().getId() + ": Eingabe: " + strInput);

        // Die Eingabe in "UpperCase" umwandeln und als komplette Zeile an Client zurückschieben.
        // "println" sorgt dafür, dass die Daten gesendet werden.
        out.println(strInput.toUpperCase());
        
        System.out.println("Thread " + Thread.currentThread().getId() + " für Clientanfrage next round");
      }

      System.out.println("Thread " + Thread.currentThread().getId() + " ist fertig!");
    }
    catch (IOException ioEx)
    {
      System.out.println("Fehler beim Schreiben:" + ioEx.getMessage());
    }
  }
}

package de.fhw.swtprojekt.knauf.sockettest.client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

/**Client-Main-Class, baut eine Socket-Verbindung zum Server auf und schickt die 
 * Tastatureingaben zeilenweise dahin. Eingabe von "X" beendet das Programm.
 * 
 * @author Wolfgang Knauf
 *
 */
public class TextClient
{
  /**Main-Methode, hier läuft der ganze Thread ab.
   * 
   * @param args
   */
  public static void main(String[] args)
  {
    System.out.println ("Text eingeben, 'Enter' schickt ihn zum Server. Eingabe von 'X' zum Beenden!");
    
    // Tastatureingaben werden eingelesen:
    BufferedReader reader = new BufferedReader ( new InputStreamReader (System.in));
    
    //Server-Verbindung aufbauen:
    Socket socketServer = null;
    try
    {
      socketServer = new Socket ("localhost", 13000);
    }
    catch (UnknownHostException ex)
    {
      System.out.println("UnknownHostException bei Verbindung zu Host 'localhost', Port 13000: " + ex.getMessage());
      System.exit(-1);
    }
    catch (IOException ex)
    {
      System.out.println("IOException bei Verbindung zu Host 'localhost', Port 13000: " + ex.getMessage());
      System.exit(-1);
    }
    
    try
    {
      //Eingabe-Reader/Ausgabe-Writer erzeugen:
      PrintWriter out = new PrintWriter(socketServer.getOutputStream(), true);
      BufferedReader in = new BufferedReader(new InputStreamReader(socketServer.getInputStream()));
      //Solange der User etwas eingibt (und danach Enter drückt), werden die Daten
      //zum Server geschickt. Eingabe von "X" beendet alles.
      String textInput = null;
      while ( (textInput = reader.readLine() ) != null && !"X".equals(textInput))
      {
        System.out.println("Client-Eingabe: " + textInput);
        
        //Ab zum Server:
        out.println(textInput);
        out.flush();

        System.out.println("Warten auf Server-Antwort...");
        //Server schickt uns "toUpper" der Eingabe:
        String textServer = in.readLine();
        System.out.println("Server-Antwort: " + textServer);
      }
      //User hat "X" eingegeben: Socket dichtmachen.
      socketServer.close();
    }
    catch (IOException e)
    {
      System.out.println ("IOException: " + e.getMessage());
      System.exit(-1);
    }
  }
}

Objekte versenden

import java.awt.Point;
import java.io.ObjectInputStream;

....
  
  try
  {
    //ObjectInputStream erlaubt das Einlesen von binär serialisierten Objekten:
    ObjectInputStream in = new ObjectInputStream(socketServer.getInputStream());
  
    //Hier wird ein Point-Objekt erwartet:  
    Point point = (Point) in.readObject();
	
    ...
  }
  catch (IOException e)
  {
    ...
  }
  catch (ClassNotFoundException classEx)
  {
    ...
  }

import java.io.ObjectOutputStream;
import java.awt.Point;

...

  try
  {
    ObjectOutputStream out = new ObjectOutputStream(clientSocket.getOutputStream());
    
    out.writeObject( new Point (10, 20) );
  }
  catch (IOException ioEx)
  {
    ..
  }

• Die Klasse muss das Interface java.io.Serializable implementieren.
• Die Klasse muss ein Feld "serialVersionUID" bieten:
  
  private static final long serialVersionUID = 1L;
  
  Eclipse warnt bei allen serialisierbaren Klassen (auch falls diese von einer serialisierbaren Klasse abgeleitet sind), falls es dieses Feld nicht gibt.
  Der Zahlenwert kann nach Wunsch vergeben werden. Wichtig ist, dass Client und Server Klassen verwenden, die die gleiche ID haben. Fügt man der Klasse z.B. Felder hinzu, dann sollte man auch die ID ändern, damit inkompatible Client-/Server-Versionen erkannt werden.