Question

我正在做一个小的客户端/服务器应用程序。目前，它运行良好，但是我需要添加一个“选项”。

服务器类如下：

public class Server {

    public static void main(String[] zero) throws IOException {

        ServerSocket serverSocket  ;
        Socket clientSocket ;

        DataBase DB = new DataBase();
        System.out.println("ouverture du server");
        serverSocket = new ServerSocket(2000);

        DB.printAll(); //just to see the DB.


        while(true) { 
            try {

                clientSocket = serverSocket.accept(); 
                Thread t = new Thread(new Connect(clientSocket, DB));
                t.start();

            }catch (IOException e) {
                e.printStackTrace();
            }       
        }
    }
}

因此许多客户端都可以连接到服务器。我的观点是：我希望一个连接的客户端（例如Client1）能够向他选择的另一个连接的客户端（Client2）发送消息。

我的问题是：由于所有客户端都通过此clientSocket在不同线程中连接到服务器，因此Client1如何查找/拥有/检索Client2的套接字？

我已经读过this，它提议制作一个包含每个已连接客户端的outputStream的dataoutputstream列表。这似乎是个好主意，但我还是希望对套接字做同样的事情（因为我不确定现在是否需要“数据”输出流或另一个输出流，无论如何，它都是用插槽对我来说更清楚）。

此外，Client2正在服务器上做自己的工作，其中包括交换数据，因此他将使用其输出/输入流。我必须确保不会混淆。

例如，假设Client2向服务器发送了一些内容并等待响应。然后Client1向Client2发送一些东西。 Client2收到Client1发送的内容，而不是服务器响应；因为他本来不应该收到的，这导致了致命的错误。

我已经阅读了一些有关同步线程的内容，这似乎是我所需要的，但是我是java的新手，这有点难吗？

我认为，如果我将Client2 Socket声明为已同步，则线程将等到clientSocket释放后再使用它。并且由于客户端不应该断开连接（并且如果客户端断开连接，那么套接字已关闭，因此我们无法向他发送任何信息），（client1的）线程将无法使用client2的套接字。 / p>

现在，如果我同步DataOutputStream，有时client2和服务器之间的通信涉及许多不同的输出流，因此可以自由使用DataOutputStream，但是Client2仍在等待服务器（而不是Client1）的输入，因此相同的输入。

也许我可以直接同步完整的OutputStream。也许我刚才说的没有任何意义。帮助吗？

Answer 1

好吧，自从我发布它之后，我想我也可以提出它。

所以，这并不是一个完美的解决方案（我认为），我还没有完全解决它，但是到目前为止，它似乎仍然有效。

对于第一个问题（如何检索另一个客户端套接字），我在服务器端创建一个静态哈希表，客户端名称为键，套接字为值。每当客户端连接时，他都会添加到该表中；当他断开连接时，他被删除了（我没有尝试断开连接的部分）

private static Hashtable<String,Socket> connectedClients= new Hashtable<String, Socket>();
public static void setConnectedClient(String username, Socket clientSocket) {
    connectedClients.put(username, clientSocket);
}

public static void disconnectClient(String user) {
    connectedClients.remove(user);
}

因此，无论我在服务器端的程序中处于什么位置，我都可以检索客户端套接字（知道他的用户名）。

对于第二个问题（如何避免与其他客户端一起使用服务器混淆），我正在创建第二个套接字。这意味着，在客户端上有两个套接字：一个用于与服务器通信，另一个用于在另一个端口上与客户端（来自服务器）通信。这意味着我在服务器端的另一个端口上还有另一个服务器套接字。因此，当客户端连接到服务器时，将在客户端和服务器端创建第二个套接字。

        Socket TCHATSocket = Server.getServerSocket().accept(); //create a new socket specifically for TCHAT
        Server.setConnectedClient(user, TCHATSocket); //register the client ID & TchatSocket in the list of connected clients.

现在，在客户端，我必须继续侦听此套接字的任何输入（以防其他客户端希望通过服务器与我通信），但是当我正在使用服务器进行操作时，则不能。

为此，我在客户端创建了另一个线程。客户端连接后，它将启动创建第二个套接字的线程，并等待服务器的输入。但是，当客户端启动任何涉及与服务器通信的功能时，该线程将暂停，然后在功能结束时不暂停。这是线程类：

package client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

public class TCHAT extends Thread{
    private InputStream in;
    private OutputStream out;
    private Socket pakeSocket;
    private String message;
    private volatile boolean pause = false;

    public void pause() {
        pause = true;
    }

    public void unPause() {
        pause = false;
        synchronized(this) {
            notify();
        }

    }

    public TCHAT() {
        try {
            tchatSocket = new Socket(InetAddress.getLocalHost(),2004);
            in = tchatSocket.getInputStream();
            out = tchatSocket.getOutputStream();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void run(){
        while(!tchatSocket.isClosed()) {

            if(pause) {
                System.out.println("TCHAT paused");
                synchronized (this) {
                    try {
                        wait();// wait until someone calls notify() (by calling the method unPause)
                    }catch (InterruptedException e) {           
                        e.printStackTrace();            
                    }
                }
            }

            else {
                System.out.println("Waiting for TCHAT demand");
                try {
                    BufferedReader br = new BufferedReader(new InputStreamReader(in));
                    message = br.readLine();
                    System.out.println(message);
                    //Find a way to blok the while after receiving the message:
                    tchatSocket.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }


        }
    }

}

如您所见，它并没有真正终止：现在，我只是从服务器收到一条消息，然后关闭套接字；但是我想您可以在关闭它之前做任何您想做的事情。另外，由于某种原因，我在调用pause（）时从未收到“ TCHAT暂停”消息，并且在我取消暂停时也没有收到“等待TCHAT需求”消息，但是它似乎可以正常工作（因为没有暂停其他客户端功能将无法正常工作，并且在这里它们可以正常工作，并且即使上传后或其他情况下，客户端也可以正确接收来自服务器的消息。）

基本上，当我想使用客户端功能时，我只是这样做：

TCHAT.pause();
upload(file); //or any function involving client/server communication
TCHAT.unpause();

希望它能对某人有所帮助，但仍然乐于助人：）

Java客户端-服务器-具有同步线程的客户端

1 个答案: