Advanced   Java   Services

Sockets

Ein einfaches Server/Client Beispiel das Threads verwendet

Das folgende Beispiel zeigt einen einfachen Client, der eine Verbindung zu einem Server aufnimmt. Der Server liefert das aktuelle Datum plus Uhrzeit und setzt dann die Verbindung zurück. Der Client kann aber einen neuen Verbindungsversuch starten (oder auch nicht...). Der Client erwartet, daß der Server seinen Dienst auf localhost auf dem Port 88 anbietet.

/*
   ein einfacher client, der über eine socketverbindung das aktuelle datum abholt.
   der client arbeitet zusammen mit einem einfachen daytimeserver.
   der client verbindet sich mit dem server, öffnet einen inputstream und liest
   daten aus dem inputstream solange bis er ein EOF erhält.
   der client erhält ein EOF, weil der server den outputstream schließt und
   damit die verbindung beendet.
   der client kann aber jederzeit wieder einen verbindungsversuch starten.
*/

import java.io.*;
import java.net.*;

public class DaytimeClient
{
   private Socket clientSocket;
   private String host = "127.0.0.1";
   private int port = 88 ;
   private BufferedInputStream inStream;

   // --------------------------- DaytimeClient --------------------------- \\
   public DaytimeClient()
   {

      while( again() )
      {
         clientSocket = createClientSocket();
         try
         {
            if (clientSocket!= null)
            {
               inStream = new BufferedInputStream( clientSocket.getInputStream() ) ;
               readInput(inStream);
            }
         }
         catch(IOException ex)
         {
            System.out.print("Fehler "+ex);
         }
      }
   }


   // ------------------------ createClientSocket ------------------------
   private Socket createClientSocket()
   {
      try
      {
         System.out.println("try to connect to " + host + " at port " + port);
         clientSocket = new Socket(host, port);
         System.out.println("Verbindung hergestellt\n");
         return clientSocket;
      }
      catch (IOException ex)
      {
         System.out.println("IOException "+ex);
         return null;
      }
   }


   // ---------------------------- readInput ----------------------------
   private void readInput(BufferedInputStream bis)
   {
      StringBuffer sb = new StringBuffer();

      int erg ;
      try
      {
         while( (erg=bis.read())!=-1 )
         {
            sb.append(""+(char)erg);
         }
         System.out.println("Server hat gesendet:");
         System.out.println(sb);
         System.out.println("Server hat Verbindung beendet\n");
         bis.close();
         clientSocket.close();
      }
      catch(SocketException ex)
      {
         System.out.println("SocketException "+ex);
      }
      catch(IOException ex)
      {
         System.out.println("IOException "+ex);
      }
   }


   private boolean again()
   {
      System.out.println("Eine Verbindung zu " + host + " auf port " + port + " versuchen ? (j/n)");
      return ( Stdin.charEingabe() == 'j' ) ? true : false;
   }


   // ------------------------------- main ------------------------------- \\
   public static void main(String[] args)
   {
      DaytimeClient daytimeClient = new DaytimeClient();
   }
   // end main
}
//  end class

Ein einfacher Server der dieseen Client bedienen kann realisiert mit der Klasse ServerSocket

Es gibt ein einziges Objekt vom Typ Serversocket. Mit server.accept() wartet das Serverobjekt dann in einem eigenen Thread auf einen Client. Nimmt ein Client Verbindung auf, so erhält er das aktuelle Datum plus Uhrzeit. Anschließend wird die Verbindung zurückgesetzt und der Server wartet auf einen neuen Client.

/*
   startet einen daytimeserver. dazu wird ein objekt vom typ ServerSocket
   angelegt. in einem eigenen thread wartet dann der server auf clients.

   der server wartet durch aufruf von
   client = server.accept()
   auf einen client.

   accept blockiert, bis ein client sich meldet
   in diesem fall wird das datum gesendet und die verbindung beendet.
   anschließend wird mit accept() wieder auf einen client gewartet.

   der serverthread kann jederzeit durch eingabe von 's' beendet werden.
   eingabe von 's' löst den aufruf von interrupt() für den laufenden thread aus.
*/
import java.io.*;
import java.net.*;
import java.util.*;

public class DaytimeServer implements Runnable
{
   private ServerSocket server;
   private Socket client;
   private int port = 0;


   public DaytimeServer(int port)
   {
      startServer(port);
   }

   // ---------------------------- startServer ----------------------------- \\
   private void startServer(int port)
   {
      try
      {
         server = new ServerSocket(port);
         System.out.println("Server wird gestartet");
         Thread serv = new Thread(this);
         serv.start();
         this.port = port;
         stopServer(serv);
      }
      catch(IOException ex)
      {
         System.out.println("cannot start server at port "+ port);
         System.out.println("Fehler "+ex);

      }
   }

   // ----------------------------- stopServer ------------------------------ \\
   private void stopServer(Thread serv)
   {
      System.out.print("Server kann jederzeit mit der eingabe von 's' (stop) beendet werden");
      char ch = Stdin.charEingabe();
      if (ch=='s')
      {
         //System.out.println("isInterrupted = " + serv.isInterrupted());
         System.out.println("versuche serverthread zu beenden");
         serv.interrupt();
         if( serv.isInterrupted() )
         {
            System.out.println("server stopped");
            System.exit(0);
         }
      }
   }

   // ------------------ von Runnable geforderte Methode ------------------- \\
   public void run()
   {
      for(;;)
      {
         try
         {
            System.out.println("\nwaiting for client on port " + port);
            client = server.accept();
            OutputStream os = client.getOutputStream();
            os.write( ((new Date()).toString()+"\n").getBytes() ) ;
            os.close();
            // schließen des os beendet die verbindung !
            client.close();
            client = null;
            System.out.println("Datum gesendet, Verbindung beendet");
         }
         catch(IOException ex)
         {
            System.out.println("IOException "+ex);
         }
      }
      // end while
   }


   // -------------------------------- main --------------------------------- \\
   public static void main(String[] args)
   {
      DaytimeServer dts = new DaytimeServer(88);
   }
}

Und so sieht das aus: