Java 客户机-服务器：如何让服务器将接收到的消息发送到另一个客户机，而不是将其发送回原始客户机？

我正在用java软件编写聊天代码， 我在Windows7上运行了两次日食。 其中一个Eclipse包括一个项目“ServerListener”，其中包含一个类

Server.java

另一个eclipse包含一个项目“Client”，并包含一个类

cl.java

我正在将消息从我的

cl.java

发送到

server.java

每次服务器收到消息时，他都会将其发送回

cl.java

（我发送消息的源），以确保消息已连接

（将消息发送到服务器并从服务器返回到同一客户端时，此部分工作正常）

我的问题是:

如何让

server.java

将消息发送到另一个客户端而不是原始客户端

如果我使用与“客户端”相同的项目运行另一个eclipse

我想两次月食一起聊天

这是服务器。java：

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class Server {

ServerSocket serverSocket;
ArrayList<ServerThread> allClients = new ArrayList<ServerThread>();

public static void main(String[] args) {
    new Server();

}

public Server() {
    // ServerSocket is only opened once !!!

    try {
        serverSocket = new ServerSocket(6000);

        System.out.println("Waiting on port 6000...");
        boolean connected = true;

        // this method will block until a client will call me
        while (connected) {
            Socket singleClient = serverSocket.accept();
            // add to the list
            ServerThread myThread = new ServerThread(singleClient);
            allClients.add(myThread);
            myThread.start();
        }

        // here we also close the main server socket
        serverSocket.close();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}

class ServerThread extends Thread {
    Socket threadSocket;
    String msg;
    boolean isClientConnected;
    InputStream input;
    ObjectInputStream ois;
    OutputStream output;
    ObjectOutputStream oos; // ObjectOutputStream

    public ServerThread(Socket s) {
        threadSocket = s;
    }

    public void sendText(String text) {
        try {
            oos.writeObject(text);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void run() {

        try {
            input = threadSocket.getInputStream();
            ois = new ObjectInputStream(input);
            output = threadSocket.getOutputStream();
            oos = new ObjectOutputStream(output);

            // get the user name from the client and store
            // it inside thread class for later use
            //msg = (String) ois.readObject();
            isClientConnected = true;
            //System.out.println(msg);
            for(ServerThread t:allClients)
                t.sendText("User has connected...");

            // send this information to all users
            // dos.writeUTF(userName + " has connected..");
            // for(ServerThread t:allClients)
            // t.sendText(msg);

            while (isClientConnected) {
                System.out.println("connect ... ");
                try {
                    msg = (String) ois.readObject();
                    System.out.println(msg);
                    if (msg.equals("quit"))
                        break;

                    for (ServerThread t : allClients)
                        t.sendText(msg);
                } catch (Exception e) {

                }
            }
            // close all resources (streams and sockets)
            ois.close();
            oos.close();
            threadSocket.close();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

import java.io.*;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class cl {

public static final String HOST = "127.0.0.1";
public static final int PORT = 6000;

static ConnectThread clientThread;
boolean isConnected;
static boolean isOnline = false;
static Scanner scanner = new Scanner(System.in);
static String msg;

public static void main(String[] args) {
    new cl();

}

public cl() {
    connectUser();
}

public void connectUser() {
    clientThread = new ConnectThread();
    clientThread.start();

}


class ConnectThread extends Thread {
    InputStream input;
    OutputStream output;
    ObjectOutputStream oos;
    Socket s;

    public void sendText(String text) {
        try {
            System.out.println("sending text to server..");

            oos.writeObject(text);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void run() {
        try {
            s = new Socket(HOST, PORT);
            output = s.getOutputStream();
            oos = new ObjectOutputStream(output);
            isOnline = true;
            isConnected = true;
            new ListenThread(s).start();
            while (isOnline) {
                System.out.println("Enter a Text to send:");
                msg = scanner.nextLine();
                clientThread.sendText("amjad: " + msg);
            }




        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

class ListenThread extends Thread {

    Socket s;
    InputStream input;
    ObjectInputStream ois;

    public ListenThread(Socket s) {
        this.s = s;
        try {
            input = s.getInputStream();
            ois = new ObjectInputStream(input);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public void run() {
        while (isConnected) {
            try {
                final String inputMessage = (String) ois.readObject();

                System.out.println(inputMessage);

            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }
}

}

---

提前感谢

现在正在发生的事情，以及您不喜欢它的哪些方面？现在，当我从客户端发送消息时，它会到达服务器，服务器会将消息发送回客户端以确保连接，客户端会得到它。。。。。。。。。。。。。。我想要什么？这是我发送到服务器的消息，服务器将其发送到特定的客户端，而不是返回给我。