如何在两个 UDP 客户端之间发送消息？

Question

我想做的是第 2 组客户并让他们相互交流。因此，如果连接了 2 个客户端，它们将只能相互通信，如果连接了第三个客户端，它将无法与其他 2 个客户端通信，但它会创建另一组 2 个客户端，依此类推......对现在，如果客户端发送一条消息，它会将其发送给所有客户端，但我不确定如何让它们像点对点连接一样以 2 为一组进行通信。

class Server {

private static DatagramSocket socket = null;

private static Map<Session, Integer> sessions = new HashMap<Session, Integer>();

private static Session session = new Session();

public static void main(String[] args) {

     
    try {
        socket = new DatagramSocket(6066);

    } catch (SocketException e) {

        System.out.println("[SERVER] Unable to launch server on port: " + socket.getLocalPort());
    }

    System.out.println("[SERVER] Server launched successfully on port " + socket.getLocalPort());

    Thread thread = new Thread(new Runnable() {

        @Override
        public void run() {

            byte[] buffer = new byte[100];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

            while (true) {
                Arrays.fill(buffer, (byte) 0);
                try {
                    socket.receive(packet);
                } catch (IOException e) {
                    System.out.println("[SERVER] Unable to receive packets from buffer");
                }

                InetAddress ip = packet.getAddress();
                int port = packet.getPort();
                String data = new String(packet.getData()).trim();
                
                
                if(session.getIp1() == null) {
                    session.setIp1(ip);
                    session.setPort1(port);
                    session.setData1(data);
                    
                } else {
                    session.setIp2(ip);
                    session.setPort2(port);
                    session.setData2(data);
                    
                }
                

                DatagramPacket pt = new DatagramPacket(packet.getData(), packet.getData().length, ip, port);

                try {
                    socket.send(pt);
                } catch (IOException e) {
                    System.out.println("[SERVER] Unable to send packets to client.");
                }

            }

        }
    });
    thread.start();
    
}
}

客户：

public class Client {

private static DatagramSocket socket = null;

public static void main(String[] args) {

    System.out.println("Send to server:");

    Scanner scanner = new Scanner(System.in);

    while (true) {

        try {
            // port shoudn't be the same as in TCP but the port in the datagram packet must
            // be the same!
            socket = new DatagramSocket();
        } catch (SocketException e1) {
            System.out.println("[CLIENT] Unable to initiate DatagramSocket");
        }

        InetAddress ip = null;

        try {
            ip = InetAddress.getByName("127.0.0.1");
        } catch (UnknownHostException e) {
            System.out.println("[CLIENT] Unable to determine server IP");
        }

        // must be in a while loop so we can continuously send messages to server
        String message = null;

        Thread thread = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                receive();
            }
        });
        thread.start();
        
        while (scanner.hasNextLine()) {
            message = scanner.nextLine();

            byte[] buffer = message.getBytes();

            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, ip, 6066);

            try {
                socket.send(packet);
            } catch (IOException e) {
                System.out.println("[CLIENT] Unable to send packet to server");
            }
        }

    }

}

private static void receive() {
    
    // receiving from server

    byte[] buffer2 = new byte[100];

    DatagramPacket ps = new DatagramPacket(buffer2, buffer2.length);

    while (true) {
        try {
            socket.receive(ps);
        } catch (IOException e) {
            System.out.println("[CLIENT] Unable to receive packets from server.");
        }

        System.out.println("[SERVER] " + new String(ps.getData()));

    }
}
}

对象class:

public class Session {

private InetAddress ip1;
private int port1;
private String data1;

private InetAddress ip2;
private int port2;
private String data2;

public Session() {
    
}

public InetAddress getIp1() {
    return ip1;
}

public void setIp1(InetAddress ip1) {
    this.ip1 = ip1;
}

public int getPort1() {
    return port1;
}

public void setPort1(int port1) {
    this.port1 = port1;
}

public String getData1() {
    return data1;
}

public void setData1(String data1) {
    this.data1 = data1;
}

public InetAddress getIp2() {
    return ip2;
}

public void setIp2(InetAddress ip2) {
    this.ip2 = ip2;
}

public int getPort2() {
    return port2;
}

public void setPort2(int port2) {
    this.port2 = port2;
}

public String getData2() {
    return data2;
}

public void setData2(String data2) {
    this.data2 = data2;
}




}

Answer 1

目前，您将客户的信息存储在一个数组中。创建一个包含两个客户端会话数据的对象。当新客户端尝试连接时，查看是否有任何对象有空闲点，如果没有，则创建一个新对象并等待新参与者；否则，加入现有会话。

Hackish 方式：创建一个 Map 然后根据 userCounts = 1 进行过滤，然后将会话加入第一个返回的对象。

如何在两个 UDP 客户端之间发送消息？

How to send messages between two UDP clients?

java

networking

udp