# Serverstruktur



## Shiby (23. Dez 2014)

Hallo Leute,
ich möchte einen Multi-Client-Server schreiben der wie folgt funktioniert:
Der Server soll darauf warten, dass jeder angemeldete Client ihm eine Nachricht schickt, man kann die Nachricht noch ändern, solange noch nicht alle Clients eine Nachricht versendet haben.
Haben alle Clients eine Nachricht an den Server gesendet, so werden die vom Server gesammelten Nachrichten an alle Clients gesendet.

Den bisherigen Code habe ich mir aus einem ChatServer aus dem Internet zusammelgebastelt.
Diese sendet eine erhaltende Nachricht umgehend an alle Clients.
Wie kann ich es ändern, dass der Server oben beschriebenes Verhalten aufweist?
Ich müsste irgendwie beim annehmen der Verbindung an das Client-Objekt rankommen oder?

Server

```
public class Server 
{
	// The default port number.
	private static final int DEFAULT_PORTNUMBER = 2227;	
	private static final int DEFAULT_MAXCLIENTS = 10;
	
              private ServerSocket serverSocket;
	public static ArrayList<ClientThread> threads = new ArrayList<>();
	
	public Server() throws IOException
	{
		serverSocket = new ServerSocket(DEFAULT_PORTNUMBER);
		waitForConnection();
	}
  
	public void waitForConnection() throws IOException
	{
		while(true)
		{		      
		   Socket clientSocket = serverSocket.accept();	
		    
		   ClientThread temp = new ClientThread(clientSocket, threads);
		   threads.add(temp);
		   temp.start();		  
		}
	}  
	
	public void shutDown()
	{
		try 
		{
			serverSocket.close();
		} 
		catch (IOException e) 
		{
			
		}
	}
}
```

ClientThread

```
public class ClientThread extends Thread
{
	private DataInputStream is = null;
	private PrintStream os = null;
	private Socket clientSocket = null;
	private final ArrayList<ClientThread> threads;
	


	public ClientThread(Socket pClientSocket, ArrayList<ClientThread> pThreads)throws IOException
	{
		clientSocket = pClientSocket;

		is = new DataInputStream(clientSocket.getInputStream());
		os = new PrintStream(clientSocket.getOutputStream());

		threads = pThreads;
	}

	@Override
	public void run() 
	{
		while (true)
		{
			String line = "";

			try
			{
				line = is.readLine();
			}
			catch (IOException e)
			{

			}
			
			if (line.equals("end"))
			{
				break;
			}

			for (ClientThread ct : threads) 
			{				
			    ct.os.println(line);					
			}
		}

		try 
		{
			is.close();
			os.close();
			clientSocket.close();
		} 
		catch (IOException e)
		{
		
		}
	}
}
```

Client

```
public class Client
{
    private Socket socket;
    private OutputStream outputStream;
    private BufferedReader reader;
    private String recivedMessage;

    public Client(String server, int port)
    {
        try
        {
            socket = new Socket(server, port); 
            reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            outputStream = socket.getOutputStream();
        }
        catch(IOException e)
        {
            
        }

        Thread receivingThread = new Thread()
        {
          @Override
          public void run() 
          {
              try
              {                 
                  String line;
                  while ((line = reader.readLine()) != null)
                  {
                      recivedMessage = line;
                  }
              } 
              catch (IOException ex) 
              {
 
              }
          }
        };
        receivingThread.start();
    }

    public void send(final String pMessage)
    {
        try 
        {
            outputStream.write((pMessage + "\r\n").getBytes());
            outputStream.flush();
        }
        catch(IOException e)
        {
            
        }
    }
    
    public String getRecivedMessage()
    {
       return recivedMessage; 
    }
    
    public void disconnect()
    {
        try
        {
            socket.close();
            reader.close();
            outputStream.close();
        }   
        catch(IOException e)
        {
            
        }
    }
}
```


----------



## senior.weber (28. Dez 2014)

Du könntest im ClientThread warten, bis "threads" eine gewisse Grösse hat - dann schreiben.


----------

