java服务器套接字将数据发送到错误的客户端

如标题所示，如果您尝试执行此程序，启动2个客户端，并尝试向第一个客户端发送消息“login”或“register”，服务器将接收输入，但将响应重定向到第二个套接字（最后一个连接的套接字）。当服务器试图向客户机发送响应时，您可以通过查看服务器控制台上打印的端口号看到这一点

public class Server {
    private ServerSocket server;

    public Server() {
        try {
            server = new ServerSocket(10000);
            System.out.println("[INFO] server running");
        } catch (IOException e) {
            System.out.println(e);
        }
    }

    public static void main(String[] args) {
        Server server = new Server();
        server.run();
    }

    public void run() {
        try {
            while (true) {
                Socket clientRequest = server.accept();
                new Thread(new ServerThread(clientRequest)).start();
            }
        } catch (IOException e) {
            System.out.println(e);
        }
    }
}

class ServerThread实现可运行{
专用静态插座；
私有静态连接dbConnection=null；
私有静态OutputStream OutputStream；
私有静态ObjectOutputStream ObjectOutputStream；
私有静态InputStream InputStream；
私有静态ObjectInputStream ObjectInputStream；
私有静态列表消息=new ArrayList（）；
私有静态消息摘要；
私有静态字符串username=“”；
私有静态布尔invalidUsername；
公共服务器线程（套接字richiestaClient）{
试一试{
套接字=richiestaClient；
System.out.println（“[INFO]”+套接字+“已连接”）；
outputStream=socket.getOutputStream（）；
objectOutputStream=新的objectOutputStream（outputStream）；
inputStream=socket.getInputStream（）；
objectInputStream=新objectInputStream（inputStream）；
}捕获（IOE异常）{
System.out.println（“[错误]错误di i/o”）；
}
}
公开募捐{
//Conversazine lato服务器
试一试{
布尔活动=真；
while（活动）{
System.out.println（“[THREAD]”+THREAD.currentThread（）.getName（））；
System.out.println（“[DEBUG]当前套接字：“+socket”）；
String msg=（String）objectInputStream.readObject（）；
System.out.println（“[客户端]”+msg）；
//--为用户登录/注册选择案例--
开关（msg）{
案例“登录”：
登录（数据库连接）；
打破
“登记册”一案：
寄存器（数据库连接）；
打破
违约：
打破
}
}
}捕获（IOException | ClassNotFoundException e）{
System.out.println（“[ERROR]errore nello switch azioni ioexception”+e）；
}
}
专用静态无效寄存器（连接dbConnection）{
System.out.println（“[THREAD]”+THREAD.currentThread（）.getName（））；
System.out.println（“[DEBUG]客户机选择的寄存器”+套接字）；
消息。添加（“用户名”）；
添加（“您选择的注册”）；
invalidUsername=true；
while（invalidUsername）{
添加（“输入您想要的用户名”）；
发送（信息）；
//获取用户名（假设不用于测试目的）
布尔usernameExists=false；
如果（用户名存在）{
System.out.println（“[DEBUG]用户名存在，不可用于注册”）；
消息。添加（“用户名”）；
添加（“对不起，用户名为：（”）；
}否则{
System.out.println（“[DEBUG]用户名不存在，可用于注册”）；
消息。添加（“密码”）；
添加（“用户名尚未获取：）”；
invalidUsername=false；
}
}
System.out.println（“[DEBUG]用户名未使用，将结果发送到”+套接字）；
}
私有静态无效登录（连接dbConnection）{
System.out.println（“[THREAD]”+THREAD.currentThread（）.getName（））；
System.out.println（“[DEBUG]客户端选择登录”+套接字）；
消息。添加（“用户名”）；
添加（“您选择的登录”）；
添加（“输入您的用户名”）；
发送（信息）；
试一试{
用户名=（字符串）objectInputStream.readObject（）；
System.out.println（“[INFO]从“+socket”接收“+username+”）；
}捕获（ClassNotFoundException | IOException e）{
System.out.println（“[DEBUG]等待客户端登录用户名时出错”）；
}
}
//发送消息、刷新流和清除消息列表
私有静态无效发送（列表消息发送）{
System.out.println（“[THREAD]”+THREAD.currentThread（）.getName（））；
System.out.println（“[DEBUG]将数据发送到”+套接字）；
试一试{
objectOutputStream.writeObject（messagesToSend）；
objectOutputStream.flush（）；
messages.clear（）；
}捕获（IOE异常）{
System.out.println（“[错误]发送消息时出错”）；
}
}
}

公共类客户端{
专用静态插座；
私有静态OutputStream OutputStream；
私有静态ObjectOutputStream ObjectOutputStream；
私有静态InputStream InputStream；
私有静态ObjectInputStream ObjectInputStream；
公共客户机（）{
试一试{
插座=新插座（“127.0.0.1”，10000）；
outputStream=socket.getOutputStream（）；
objectOutputStream=新的objectOutputStream（outputStream）；
inputStream=socket.getInputStream（）；
objectInputStream=新objectInputStream（inputStream）；
}捕获（IOE异常）{
系统输出打印ln（e）；
}
}
公共静态void main（字符串[]args）{
客户端=新客户端（）；
client.conversazione（）；
}
公共对话（一）{
//conversazione lato客户端
扫描仪扫描=新扫描仪（System.in）；
String命令=“默认”；
字符串消息=”；
字符串username=“”；
列表消息=新建ArrayList（）；
System.out.println（“您想做什么？（登录/注册）”；
class ServerThread implements Runnable {
    private static Socket socket;

    private static Connection dbConnection = null;
    private static OutputStream outputStream;
    private static ObjectOutputStream objectOutputStream;
    private static InputStream inputStream;
    private static ObjectInputStream objectInputStream;

    private static List<String> messages = new ArrayList<String>();
    private static MessageDigest messageDigest;

    private static String username = "";
    private static boolean invalidUsername;

    public ServerThread(Socket richiestaClient) {
        try {
            socket = richiestaClient;
            System.out.println("[INFO] " + socket + " connected ");
            outputStream = socket.getOutputStream();
            objectOutputStream = new ObjectOutputStream(outputStream);
            inputStream = socket.getInputStream();
            objectInputStream = new ObjectInputStream(inputStream);
        } catch (IOException e) {
            System.out.println("[ERROR] errore di i/o");
        }
    }

    public void run() {
        // conversazione lato server
        try {
            boolean active = true;
            while (active) {
                System.out.println("[THREAD] " + Thread.currentThread().getName());
                System.out.println("[DEBUG] current socket: " + socket);
                String msg = (String) objectInputStream.readObject();
                System.out.println("[CLIENT] " + msg);
                // -- SELECT CASE FOR USER LOGIN/REGISTER --
                switch (msg) {
                    case "login":
                        login(dbConnection);
                        break;
                    case "register":
                        register(dbConnection);
                        break;
                    default:
                        break;
                }
            }
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("[ERROR] errore nello switch azioni ioexception " + e);
        }
    }

    private static void register(Connection dbConnection) {
        System.out.println("[THREAD] " + Thread.currentThread().getName());
        System.out.println("[DEBUG] client selected register " + socket);
        messages.add("username");
        messages.add("You selected register");
        invalidUsername = true;
        while (invalidUsername) {
            messages.add("input the username you want");
            send(messages);
            // getting username (assuming not taken for testing purpose)
            boolean usernameExists = false;
            if (usernameExists) {
                System.out.println("[DEBUG] username exists, not available for the registration");
                messages.add("username");
                messages.add("sorry, username is taken :(");
            } else {
                System.out.println("[DEBUG] username does not exists, available for the registration");
                messages.add("password");
                messages.add("username is not taken yet :)");
                invalidUsername = false;
            }
        }
        System.out.println("[DEBUG] username not taken, sending result to " + socket);
    }

    private static void login(Connection dbConnection) {
        System.out.println("[THREAD] " + Thread.currentThread().getName());
        System.out.println("[DEBUG] client selected login " + socket);
        messages.add("username");
        messages.add("You selected login");
        messages.add("Input your username");
        send(messages);
        try {
            username = (String) objectInputStream.readObject();
            System.out.println("[INFO] received " + username + " from " + socket);
        } catch (ClassNotFoundException | IOException e) {
            System.out.println("[DEBUG] error while waiting for client login username");
        }
    }

    // sending messages, flushing stream and clearing messages list
    private static void send(List<String> messagesToSend) {
        System.out.println("[THREAD] " + Thread.currentThread().getName());
        System.out.println("[DEBUG] Sending data to " + socket);
        try {
            objectOutputStream.writeObject(messagesToSend);
            objectOutputStream.flush();
            messages.clear();
        } catch (IOException e) {
            System.out.println("[ERROR] error occurred while sending message");
        }
    }
}

public class Client {
    private static Socket socket;

    private static OutputStream outputStream;
    private static ObjectOutputStream objectOutputStream;
    private static InputStream inputStream;
    private static ObjectInputStream objectInputStream;

    public Client() {
        try {
            socket = new Socket("127.0.0.1", 10000);
            outputStream = socket.getOutputStream();
            objectOutputStream = new ObjectOutputStream(outputStream);
            inputStream = socket.getInputStream();
            objectInputStream = new ObjectInputStream(inputStream);
        } catch (IOException e) {
            System.out.println(e);
        }
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.conversazione();
    }

    public void conversazione() {
        // conversazione lato client
        Scanner scan = new Scanner(System.in);
        String command = "default";
        String message = "";
        String username = "";
        List<String> messages = new ArrayList<String>();
        System.out.println("what do you want to do? (login/register)");
        while (true) {
            try {
                switch (command) {
                    case "default":
                        System.out.println("[DEBUG] switch option: default");
                        message = scan.nextLine();
                        send(message);
                        break;
                    case "username":
                        System.out.println("[DEBUG] switch option: username");
                        username = scan.nextLine();
                        send(username);
                        break;
                    case "password":
                        System.out.println("[DEBUG] switch option: password");
            // not implemented yet
                        break;
                    default:
                        break;
                }
        // getting messages from the server, using the first one as "header" to know what to do
                System.out.println("[DEBUG] waiting for message " + socket);
                messages = (List<String>) objectInputStream.readObject();
                System.out.println("Received [" + (messages.size() - 1) + "] messages from: " + socket);
                command = messages.get(0);
                messages.remove(0);
                for (String msg : messages) {
                    System.out.println(msg);
                }
                messages.clear();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    // send message to the server and reset the stream
    public static void send(String message) {
        try {
            System.out.println("[DEBUG] sending data as " + socket);
            objectOutputStream.writeObject(message);
            objectOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}