Я пытаюсь сгруппировать двух клиентов и заставить их общаться друг с другом. Таким образом, если подключены 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()));

    }
}
}

Класс объекта:

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;
}




}
0
duh ikal 12 Фев 2021 в 04:28

1 ответ

Лучший ответ

В настоящее время вы храните информацию о клиенте в массиве. Создайте объект, в котором он будет содержать данные двух клиентских сеансов. Когда новый клиент пытается подключиться, посмотрите, есть ли какие-либо объекты, у которых есть свободное место, если нет, создайте новый объект и дождитесь нового участника; в противном случае присоединитесь к существующему сеансу.

Хакерский способ: создайте карту , затем отфильтруйте на основе userCounts = 1 и затем присоединитесь к сеансу с первым возвращенным объектом.

1
PineappleEater 12 Фев 2021 в 03:29