Socket Chat Server für mehrere Clients

[lc]

Hallo,
Bin gerade dabei einen Chat für mehrere Clients zu schreiben. Ich lasse also ein ServerSocket in einer Schleife durchgehend neue Clients connecten, hier mal der Code dazu:

    public void run() {
        while (isEnabled) {
            try {
                Socket s=ss.accept();
                System.out.println("Client "+s.getInetAddress()+" connected!");
                new ServerThread(s).start();
            } catch (IOException ex) {
                Logger.getLogger(AcceptThread.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
    public void setisEnabled(boolean a) {
        isEnabled = a;
    }

Ok, das funktioniert soweit ja schon, aber nur zwischen Client und Server, aber nicht untereinander zwischen den Clients wenn sich mehrere einloggen. Jetzt stehe ich vor einem Problem. Wie könnte ich das realisieren, dass die Clients auch miteinander kommunizieren können?

 

[Gast2]

- Client schickt seine Nachricht an den Server
- Server verteilt diese Nachricht an alle Clients die verbunden sind (hier kannste dann z.b. noch Gruppeneinteilungen machen, Chaträume, etc.)

 

[oversoul]

Wenn noch nicht so aufwendig sein soll dann am besten so:

Client sendet Text zum Server -> Server speichert den Text in eine Variable ->
Server sendet den Text an alle bekannten/verbundenen Sockets (am besten dafür alle sockets irgendwo in einem Array oder in einer Liste speichern)

 

[lc]

Ok, mein Problem ist jetzt folgendes:
Jeder Client hat seinen eigenen ServerThread. Wie kann ich nun anderen ServerThreads sagen, dass ClientXY eine Nachricht gesendet hat?

 

[tuttle64]

Ok, mein Problem ist jetzt folgendes:
Jeder Client hat seinen eigenen ServerThread. Wie kann ich nun anderen ServerThreads sagen, dass ClientXY eine Nachricht gesendet hat?

Im folgenden Link findest Du ein Beispiel, wo genau das gemacht wird. Das Prinzip ist trivial, aber gut durchdacht: Die Client-Threads werden in einem Clients-Array gespeichert. Will man nun an alle Clients eine Nachricht senden, holt man mit einer Schleife Client für Client und setzt ein Client[x].send(message) ab.

Creating a simple Chat Client/Server Solution

 

[JavaN3rd]

Andere Möglichkeit wäre ein Peer to Peer System, bei diesem System wird zuerst ein Hostserver gestartet und dieser sammelt z.B. alle IP sendet sie jedem Client und jeder Client startet dann selber einen Server, und verbindet sich zu allen anderen. So ist dann jeder mit jedem verbunden.

Für einen einfachen Chatserver ist das aber ziemlich sicher zu aufwändig und die Vorteile zu klein.

 

[CHE123]

hi,

etwas kürzer als das bsp von oben:

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.util.ArrayList;
import java.util.Collection;

public class Chat
{
  static private int delim = 13; // CR, LF, ETX...
  static private final Collection<Servant> servants = new ArrayList<Servant>();
  // TODO servants nicht synced => ConcurrentModificationException

  static private final class Servant implements Runnable
  {
    private final Socket so;
    private final ByteArrayOutputStream baos;
    private final byte b[];
    private volatile int running;

    private Servant(Socket so) {
      this.so = so;
      b = new byte[1024*1024]; 
      baos = new ByteArrayOutputStream(b.length);
    }
    
    @Override
    public void run() {
      try {
        for(running = 2; running == 2; ) {
          try {
            final String msg = readMessage();
            if(msg ==  null) {
              throw new IOException("socket closed by peer");
            }
            for(Servant servant : servants) {
              if(servant != this) {
                try {
                  servant.writeMessage(msg);
                }
                catch(Exception x) {
                  x.printStackTrace();
                }
              }
            }
          }
          catch(SocketTimeoutException _) {
             // gibt die möglichkeit, running zu checken
          }
        }
      }
      catch(final Exception x) {
        x.printStackTrace();
      }
      finally {
        servants.remove(this);
        try {
          so.close();
        }
        catch(final Exception x) {
          x.printStackTrace();
        }
      }
    }

    private synchronized void writeMessage(String msg) throws Exception {
      final OutputStream os = so.getOutputStream();
      os.write(msg.getBytes());
      os.write(delim);
      os.flush();
    }

    private String readMessage() throws Exception {
      final InputStream is = so.getInputStream();
      for(int x;;) {
        final byte[] a = baos.toByteArray(); // give me a copy
        for(int end = 0; end < a.length; end++) {
          if(a[end] == delim) { // delimiter found
            baos.reset();
            if((x = a.length - end - 1) > 0) {
              baos.write(a, end + 1, x);
            }
            return new String(a, 0, end);
          }
        }
        if((x = is.read(b)) <= 0) {
          return null;
        }
        baos.write(b, 0, x);
      }
    }
  }

  public static void main(String[] args) throws Exception {
    final ServerSocket ss = new ServerSocket(9999);
    try {
      for(;;) {
        final Socket so = ss.accept();
        so.setKeepAlive(true);
        so.setSoTimeout(1000);
        final Servant servant = new Servant(so);
        servants.add(servant);
        new Thread(servant).start();
      }
    }
    finally {
      ss.close();
    }
  }
}

andere, etwas komplizierte möglichkeiten sind das java.nio bzw. einen message-broker ala ActiveMQ zu benutzen.
g,
Christian

 

[dayaftereh]

Wenn es um NIO geht würde ich mir Mal Mina Apache anschauen! Habe damit große Erfolge gemacht! ein schönes Beispiel wie man Mina einsetzt ist SIMON! Nur so als anmärkung!