ZFX + Developia

Code: Alles auswählen

import java.util.List;

import java.net.Socket;
import java.net.ServerSocket;
import java.net.BindException;
import java.net.SocketException;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;

import network.Logger;
import network.LoggerImpl;

/**
 * Ein Server der per TCP-Verbindung die Berechnung von Primzahlen ermoeglicht.
 */
public class PrimeServerImpl implements PrimeServer
{
  private int clientNumber;

  /** Prozess zum Verwalten der Clients. */
  private PrimeServerProcess process;

  /** Verwaltungssocket. */
  private ServerSocket serverSocket;

  /** Logger für den Server. */
  private Logger serverLog;

  /**
   * Startet den Server. Diese Methode muss sofort zurueckkehren.
   * 
   * Fuer jede Clientverbindung wird ein eigener Thread gestartet.
   * 
   * @param port
   *          tcp port
   * @throws IOException
   *           Netzwerkfehler
   */
  public void startServer(int port) throws IOException
  {
    clientNumber=1;
    serverLog = new LoggerImpl();
    try {
      serverSocket = new ServerSocket(port);

      process = new PrimeServerProcess();
      process.enable();
      final Thread workerThread = new Thread(process);
      workerThread.start();

    } catch (BindException ex) {
      ex.printStackTrace();
    }

    /*
     * out.flush();
     */
  }

  /**
   * Stoppt den Server. Das bedeutet es werden keine neuen Verbindungen mehr
   * angenommen. Bereits bestehende Verbindungen laufen normal weiter. Die
   * Methode kehrt jedoch erst zurueck, wenn alle Clients die Verbindung beendet
   * haben.
   * 
   * @throws IOException
   *           Netzwerkfehler
   * @throws InterruptedException
   *           falls beim Beenden ein Netzwerkfehler auftritt
   */
  public void stopServer() throws IOException, InterruptedException
  {
    if (serverSocket != null) {
      process.disable();
      try {
        // serverSocket.setReuseAddress(true);
        serverSocket.close();
      } catch (BindException ex) {
        ex.printStackTrace();
      }
    }
    addEntry("client disconnected,1");
  }

  /**
   * 
   * @param e
   *          wird ans Ende des Logs hinzugefuegt.
   */
  public void addEntry(String e)
  {
    if (serverLog != null) {
      serverLog.addEntry(e);
    }
  }

  /**
   * 
   * @return Liefert eine Kopie des aktuellen Logs zurueck.
   */
  public List < String > getLog()
  {
    return serverLog.getLog();
  }

  /**
   * Verwaltet den Umgang mit den Clients.
   */
  private class PrimeServerProcess implements Runnable
  {
    /** Flag zur Überprüfung der Verbindung. */
    private boolean connected;

    /** Aktiviert die Überprüfung für neue Clients. */
    public void enable()
    {
      connected = true;
    }

    /** Deaktiviert die Überprüfung für neue Clients. */
    public void disable()
    {
      connected = false;
    }

    /**
     * Threading Funktion.
     */
    @Override
    public void run()
    {
      try {
        while (connected) {
          final PrimeServerSession session = new PrimeServerSession();

          try{
            session.connectWith(servSocket.accept());
          } catch (SocketException e) {
            return;
          }

          addEntry("client connected,1");
          final Thread t = new Thread(session);
          t.start();
        }
      }catch (IOException e) {
        return;
      }
    }
  }

  /** Session pro Client. */
  private class PrimeServerSession implements Runnable
  {
    /** Socket zur Client-Kommunikation. */
    private Socket socket;

    /** Outputstream für den Socket. */
    private ObjectOutputStream out;

    /** InputStream vom Socket. */
    private ObjectInputStream in;

    /**
     * Verbindet den Server mit einem Client.
     * 
     * @param socket
     *          Socket zur Kommunikation zu einem Client.
     */
    public void connectWith(Socket socket)
    {
      this.socket = socket;
      try {
        out = new ObjectOutputStream(socket.getOutputStream());
        out.flush();
        in = new ObjectInputStream(socket.getInputStream());
      } catch (IOException io) {
        io.printStackTrace();
      }
    }

    /**
     * Diese Funktion wird in einem Thread ausgeführt.
     */
    @Override
    public void run()
    {
      if (socket == null) {
        return;
      }

      String message;
      while (true) {
        try {
          out.writeObject("1");

        } catch (IOException ioException) {
          return;

        }
        try {
          message = (String) in.readObject();
          addEntry(message);
        } catch (IOException e) {
          e.printStackTrace();
        } catch (ClassNotFoundException e) {
          return;
        }

      }
    }

    /**
     * 
     */
    private void waitNow()
    {
      try {
        wait();
      } catch (InterruptedException e) {
        assert(false);
      }
    }

  }

}