Wiele klientów jeden serwer

Witam,

Robię projekt na kryptografię i mam problem z zaimplementowaniem wątków. Chodzi o to, że mamy trzy strony Alice, Bob i zaufana trzecia strona - Trent.
Teraz tak wygląda początek strony Alice:

package kontrakt_a;

(...)

public class Kontrakt_A{
    Socket requestSocket;
    ObjectOutputStream out;
     ObjectInputStream in;
     String message;
    Kontrakt_A(){}
    void run() throws NoSuchAlgorithmException
    {
        try{

                        (...)
            requestSocket = new Socket("localhost", 2004);
            System.out.println("Podlaczono do localhost na porcie 2004");
            out = new ObjectOutputStream(requestSocket.getOutputStream());
            out.flush();
            in = new ObjectInputStream(requestSocket.getInputStream());
            

Tak wygląda Boba:

package kontrakt_b;

(...)

public class Kontrakt_B{
    ServerSocket providerSocket;
    Socket connection = null;
    ObjectOutputStream out;
    ObjectInputStream in;
    String message;
    Kontrakt_B(){}
    void run() throws NoSuchAlgorithmException
    {
        try{

                        (...)
            providerSocket = new ServerSocket(2004, 10);

            System.out.println("Waiting for connection");
            connection = providerSocket.accept();
            System.out.println("Connection received from " + connection.getInetAddress().getHostName());

            out = new ObjectOutputStream(connection.getOutputStream());
            out.flush();
            in = new ObjectInputStream(connection.getInputStream());
            sendMessage("Connection successful");

Nie wiem jak napisać trent'a żeby obie strony (Alice i Bob) mogły jednocześnie się z nim połączyć, jak to jest z tymi wątki. Znalazłem taki kod jakiegoś programu do chatu (http://stackoverflow.com/questions/12655937/console-based-application-to-gui-based-application-in-java) ale nie mogę się w nim odnaleźć. Fajnie gdyby ktoś napisał w skrócie jak zaimplementować te wątki, żeby w/w komunikacja sie udała.

sam musiałem napisać projekt na socketach i powiem, że wygodnie było użyć projektu spring integration

Trenta zrób jako serwer a Boba i Alice jako klientów. Jeśli chodzi o wielowątkowość w Socket'ach to ja zawsze robię drugi wątek dla obioru strumienia, ponieważ w momencie próby pobrania strumienia wstrzymuje program a nie powinno.

Trzeba też pamiętać gdy się robi serwer - klient+klient to przesyłanie klient do klient przebiega przez serwer (serwer odbiera wiadomośc od klienta1 i wysyła do klienta2).

Będę bardzo wdzięczny za pomoc tylko przy jednej rzeczy. Mam serwer i dwóch klientów. Wszystko działa. W jaki sposób w moim przykładzie mogę ich rozpoznawać kto jest kto ? w tym sensie, że chce np. wiedzieć, że jeden klient wysłał mi literę A drugi zaś B.

serwer:

package testtrent;

import java.io.*;
import java.net.*;
import java.util.logging.Level;
import java.util.logging.Logger;

public class TestTrent{
    ServerSocket providerSocket;
    Socket connection = null;
    ObjectOutputStream out;
    ObjectInputStream in;
    String message;
    TestTrent(){}
    void run() throws IOException
    {
            //1. creating a server socket
            providerSocket = new ServerSocket(2004, 10);
            //2. Wait for connection
            System.out.println("Waiting for connection");
                        while (true) {
                            Socket connection = providerSocket.accept();
                            Thread thr = new TestTrent.HandlerThread(connection);
                            thr.start();
                        }
            //System.out.println("Connection received from " + connection.getInetAddress().getHostName());
            

        }
    

    public static void main(String args[]) throws IOException
    {
        TestTrent server = new TestTrent();
        while(true){
            server.run();
        }
    }
        private class HandlerThread extends Thread {
        private Socket s;
        HandlerThread(Socket s) {
            this.s = s;
        }
        public void run() {
            try {
                out = new ObjectOutputStream(s.getOutputStream());
                sendMessage("Witaj");
            } catch (IOException ex) {
                Logger.getLogger(TestTrent.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        void sendMessage(String msg)
    {
        try{
            out.writeObject(msg);
            out.flush();
            System.out.println("server>" + msg);
        }
        catch(IOException ioException){
            ioException.printStackTrace();
        }
    }
     }
}

        

KlientX:

package klienttrent;

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

public class KlientTrent{
    Socket requestSocket;
    ObjectOutputStream out;
     ObjectInputStream in;
     String message;
    KlientTrent(){}
    void run()
    {
        try{
            //1. creating a socket to connect to the server
            requestSocket = new Socket("localhost", 2004);
            System.out.println("Connected to localhost in port 2004");
            //2. get Input and Output streams
            out = new ObjectOutputStream(requestSocket.getOutputStream());
            out.flush();
            in = new ObjectInputStream(requestSocket.getInputStream());
            //3: Communicating with the server
            do{
                try{
                    message = (String)in.readObject();
                    System.out.println("server>" + message);
                    sendMessage("Hi my server");
                    message = "bye";
                    sendMessage(message);
                }
                catch(ClassNotFoundException classNot){
                    System.err.println("data received in unknown format");
                }
            }while(!message.equals("bye"));
        }
        catch(UnknownHostException unknownHost){
            System.err.println("You are trying to connect to an unknown host!");
        }
        catch(IOException ioException){
            ioException.printStackTrace();
        }
        finally{
            //4: Closing connection
            try{
                in.close();
                out.close();
                requestSocket.close();
            }
            catch(IOException ioException){
                ioException.printStackTrace();
            }
        }
    }
    void sendMessage(String msg)
    {
        try{
            out.writeObject(msg);
            out.flush();
            System.out.println("client>" + msg);
        }
        catch(IOException ioException){
            ioException.printStackTrace();
        }
    }
    public static void main(String args[])
    {
        KlientTrent client = new KlientTrent();
        client.run();
    }
}

Jeśli znajdziesz odpowiedź na swoje ostatnie pytanie to napisz tutaj, proszę. Niestety mam podobny problem.

Serwer musi posiadać tablice klientów (najlepiej obiektowo i tablica dynamiczna), gdzie będzie posiadać strumienie wejściowe i wyjściowe.
Potem przy pobieraniu informacji (prawdopodobnie wielowątkowo) od klienta np. drugiego tablicaklientow.get(indeks).getMsg() będziesz wiedział że indeks odnosi się do klienta o numerze indeksu+1 :P. Mam nadzieje że zrozumiesz o co chodzi ;).

coś takiego ?

ServerSocket providerSocket = new ServerSocket(2040, 10);
Thread[] thr = new Thread[3];
                            for (int i = 0; i < thr.length; i++) {
                                Socket connection = providerSocket.accept();
                                thr[i] = new TestTrent.HandlerThread(connection);
                                thr[i].start();
                            }

To są wątki a bardziej mi chodziło o tablice klientów. Gdzie stworzyłbyś klasę Klient,która posiadałaby pola takie jak Socket i w twoim przypadku ObjectOutputStream i ObjectInputStream.
I taką tablice ArrayList<Klient> łatwiej byłoby obsługiwać.