UDP套接字在java中的聊天应用

我正在尝试使用UDP套接字在Java中创建一个非常简单的聊天应用程序。有一个服务器和多个客户端

现在我的代码是：

服务器：

package chat;

import java.io.*;
import java.net.*;
import java.util.HashMap;
import java.util.Set;

class User{
    InetAddress addr;
    int port;

    User(InetAddress a,int p){
        addr = a;
        port = p;
    }
}



public class Server {
    private static final int PORT = 27012;
    private static DatagramSocket sckt;
    private static DatagramPacket in,out;
    private static byte[] buffer;
    private static HashMap<String,User> users;
    public static void main(String[] args) {
        try{
            System.out.println("Opening port...");
            sckt = new DatagramSocket(PORT);
            users = new HashMap<String,User>();

        }
        catch(SocketException e){
            System.out.println("Port connection failed!");
            System.exit(1);
        }

        handleClient();
    }
        private static void sendMsg(InetAddress addr, int port, String msg){
            try{
            out = new DatagramPacket(msg.getBytes(),msg.length(),addr,port);
            sckt.send(out);
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    private static void handleClient(){
        try{
            String msgIn,msgOut="",senderNick;
            do{
            buffer = new byte[256];
            in = new DatagramPacket(buffer,buffer.length);
            sckt.receive(in);
            InetAddress clientAddress = in.getAddress();
            int clientPort = in.getPort();
            msgIn = new String(in.getData(),0,in.getLength());
            //print msgIn
            //System.out.println(msgIn);
                        senderNick = msgIn.substring(0,msgIn.indexOf(" "));
                        msgIn = msgIn.substring(msgIn.indexOf(" ")+1);
            if(msgIn.equals("/connect")){
                //String nick = msgIn.substring(msgIn.indexOf(" ") + 1);
                System.out.println(senderNick);
                if(users.containsKey(senderNick)){
                    msgOut = "Nick already in use!";
                }
                else{
                    users.put(senderNick, new User(clientAddress,clientPort));
                    msgOut = "Connected!";
                }
                                sendMsg(clientAddress,clientPort,msgOut);
            }
                        else if(msgIn.equals("/list")){
                            Set userNames;
                            userNames = users.keySet();
                            msgOut = "Users : \n";
                            msgOut += userNames.toString();
                            sendMsg(clientAddress,clientPort,msgOut);
                        }
                        else if(msgIn.startsWith("/msg")){
                            String tmp = msgIn.substring(msgIn.indexOf(" ")+1);
                            String receiverName = tmp.substring(0,tmp.indexOf(" "));
                            String message = tmp.substring(tmp.indexOf(" ")+1);

                            if(!users.containsKey(receiverName)){
                                msgOut = "User " + receiverName + " not found!";
                                sendMsg(clientAddress,clientPort,msgOut);
                            }
                            else{
                                User receiver = users.get(receiverName);
                                msgOut = "Message from "+  senderNick  +" : "+message;
                                sendMsg(clientAddress,clientPort,"Message Sent!");
                                sendMsg(receiver.addr,receiver.port,msgOut);
                            }

                        }
                        else if(msgIn.startsWith("/nick")){
                            String newNick = msgIn.substring(msgIn.indexOf(" ")+1);
                            if(users.containsKey(newNick)){
                                msgOut = "Nick already in use!";
                            }
                            else{
                                users.put(newNick,users.get(senderNick));
                                users.remove(senderNick);
                                msgOut = "Nick changed!";
                            }
                            sendMsg(clientAddress,clientPort,msgOut);
                        }
                        else if(msgIn.equals("/disconnect")){
                            users.remove(senderNick);
                        }

            //out = new DatagramPacket(msgOut.getBytes(),msgOut.length(),clientAddress,clientPort);
            //sckt.send(out);
            }while(true);
        }
        catch(IOException e){
            e.printStackTrace();
        }
        finally{
            System.out.println("Closing connection.");
            sckt.close();
        }
    }

}

---

我希望能够向单个用户或所有用户发送消息，但问题是我无法在客户端上接收消息，因为目前的情况是，客户端只在将消息发送到服务器后才接收消息。所以我的想法是使用一个线程来持续侦听来自服务器的消息，但它不起作用。最简单的方法是什么？

您正在尝试立即使用接收到的数据报，而不是等待创建的线程接收数据报并在变量中填充

。您可以直接在线程的代码中处理接收到的数据报，也可以使用wait（）/notify（）方案在接收到数据报时向主线程发送信号。
为什么说线程不工作？看看Netty library（）@FDinoff我对线程没有任何经验。我在客户机中有一个MessageListener类，我试图使用它来接收消息：现在我的聊天中一切正常，只是当我向另一个用户发送消息时，另一个用户没有收到。@Adrian发布代码以便我们可以查看它。（我正确地说这是单线程版本，对吗？@Adrian 1。去读一本关于线程的教程。2.不要每次循环都启动一个线程，也不要在两个地方读取套接字，这将是一个竞争条件。我现在正在线程代码中处理接收到的消息，它似乎与其他命令一起工作，但/msg仍然不工作。在原始帖子中编辑了客户端代码。
package chat;

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

public class Client {

    private static InetAddress host;
    private static final int PORT = 27012;
    private static DatagramSocket sckt;
    private static DatagramPacket in, out;
    private static byte[] buffer;
    private static String nick;

    static class MessageListener implements Runnable {
        //DatagramPacket in;
        //byte[] buffer;
        String reply;
        public void run() {
            do{
            try{
            buffer = new byte[256];
            in = new DatagramPacket(buffer,buffer.length);
            sckt.receive(in);
            reply = new String(in.getData(),0,in.getLength());
            System.out.println("SERVER> "+reply);
            }
            catch(IOException e){
                e.printStackTrace();
            }
            }while(true);
        }
    }

    public static void main(String[] args) {
        try {
            host = InetAddress.getLocalHost();

        } catch (UnknownHostException e) {
            System.out.println("Host not found!");
            System.exit(1);
        }
        connect();

    }

    private static void sendMsg(String msg) {
        try {
            out = new DatagramPacket(msg.getBytes(), msg.length(), host, PORT);
            sckt.send(out);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void connect() {
        Scanner sc = new Scanner(System.in);

        try {
            buffer = new byte[256];
            sckt = new DatagramSocket();
            String reply = "";
            do {
                System.out.println("Name: ");
                nick = sc.nextLine();
                sendMsg(nick + " /connect");
                in = new DatagramPacket(buffer, buffer.length);
                sckt.receive(in);
                reply = new String(in.getData(), 0, in.getLength());
                System.out.println("SERVER> " + reply);
            } while (!reply.equals("Connected!"));
            accessServer();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void accessServer() {
        try {
            sckt = new DatagramSocket();
            Scanner sc = new Scanner(System.in);
            String msg = "", reply = "";
            Thread myT = new Thread(new MessageListener());
            myT.start();
            do {
                System.out.print("Enter Message: ");
                msg = sc.nextLine();
                if (!msg.equals("/quit")) {
                    buffer = new byte[256];

                    sendMsg(nick + " " + msg);


                } else {
                    sendMsg(nick + " /disconnect");
                }
            } while (!msg.equals("/quit"));

            sc.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.out.println("Connection closing...");
            sckt.close();
        }

    }
}