点对点聊天应用程序使用 java 在 UDP 中工作

Question

这是一个Java程序，实现了一个简单的UDP聊天服务器。该程序允许客户端使用用户数据报协议 (UDP) 相互连接和通信。服务器是多线程的，这意味着它可以同时处理多个客户端连接。

课程包括三个班级：

UdpChatServer：这个类代表主要的服务器应用。它侦听传入的客户端连接并创建一个新的 ServerThread 实例来处理每个连接。 ServerThread：此类表示处理服务器与单个客户端之间通信的线程。它从客户端接收消息并将它们中继到适当的目的地。 ThreadCntt：此类表示处理两个客户端之间通信的线程。它从一个客户端接收消息并将它们中继到另一个客户端。 ThreadEnv：向服务器发送消息的线程。 ThreadEct：从服务器接收消息的线程。

`package Udp_version;

import java.net.*;
import java.io.*;

public class Client {
    public  static void main(String[] args){
        try {
            DatagramSocket datagramSocket = new DatagramSocket();
                InetAddress serverAddress = InetAddress.getLocalHost();
                int serverPort = 1338;
                UdpChatClient udpChatClient = new UdpChatClient(datagramSocket, serverAddress, serverPort);
                udpChatClient.start();
        }catch(IOException e){
            System.out.println("Error occurred while reading input: " + e.getMessage());
        } catch(Exception e){
            System.out.println("Error occurred while sending message: " + e.getMessage());
        }
    }
}`





`package Udp_version;

import java.net.*;
import java.io.*;
import java.nio.charset.StandardCharsets;

public class UdpChatClient extends Thread {
   DatagramSocket datagramSocket;
   InetAddress serverAddress;
   int serverPort;
   byte[] buffer;
   UdpChatClient(DatagramSocket datagramSocket,InetAddress serverAddress,int serverPort){
       this.datagramSocket = datagramSocket;
       this.serverAddress = serverAddress;
       this.serverPort = serverPort;
       buffer = new byte[10000];
   }
    public void run(){
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("Donner votre login : ");
            String login = reader.readLine();
            buffer = login.getBytes(StandardCharsets.UTF_8);
            System.out.println(login);
            System.out.println(buffer);
            DatagramPacket packet = new DatagramPacket(buffer,buffer.length,serverAddress,serverPort);
            datagramSocket.send(packet);
            System.out.println("sent0");
            while(true){
                System.out.println("choisir 1 pour lister, choisir 2 pour se connecter et 0 pour quitter : ");
                String choix = reader.readLine();
                byte[] sendData;
                if(choix.equals("1")){
                    buffer = "Lister".getBytes(StandardCharsets.UTF_8);
                    System.out.println("Working1");
                    packet = new DatagramPacket(buffer,buffer.length,serverAddress,serverPort);
                    datagramSocket.send(packet);
                    System.out.println("sent1");
                    buffer = new byte[20000];
                    packet = new DatagramPacket(buffer,buffer.length);
                    datagramSocket.receive(packet);
                    System.out.println("received1");
                    String res= new String(packet.getData(),0,packet.getLength());
                    System.out.println("\nClient connecter: ");
                    System.out.println(res);
                } else if (choix.equals("2")){
                    System.out.println("donner le login correspondant : ");
                    String logcorrespondant = reader.readLine();
                    buffer = "Se connecter".getBytes(StandardCharsets.UTF_8);
                    System.out.println("Working2");
                    buffer = new byte[20000];
                    packet = new DatagramPacket(buffer,buffer.length,serverAddress,serverPort);
                    datagramSocket.send(packet);
                    System.out.println("sent2");
                    buffer=logcorrespondant.getBytes(StandardCharsets.UTF_8);
                    packet=new DatagramPacket(buffer,buffer.length,serverAddress,serverPort);
                    datagramSocket.send(packet);
                    System.out.println("sent2");
                    ThreadEct th1 = new ThreadEct(logcorrespondant,datagramSocket,serverAddress,serverPort);
                    ThreadEnv th2 =new ThreadEnv(datagramSocket,serverAddress,serverPort);
                    th1.start();
                    th2.start();
                }else if(choix.equals("0")){
                    String message = login + ":end";
                    sendData = message.getBytes(StandardCharsets.UTF_8);
                    DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress, serverPort);
                    datagramSocket.send(sendPacket);
                    break;
                }
            }
        }catch(IOException e){
            System.out.println("Error occurred while reading input: " + e.getMessage());
        } catch(Exception e){
            System.out.println("Error occurred while sending message: " + e.getMessage());
        }
    }
}`





`package Udp_version;

import java.net.*;
import  java.io.*;

public class ThreadEct extends Thread{
    String login;
    DatagramSocket socket;
    InetAddress address;
    int port;
    ThreadEct(String log, DatagramSocket sock,InetAddress addr,int p){
        login =log;
        socket=sock;
        address = addr;
        port = p;
    }
    public void run(){
        try {
            while(true){
                byte[] buffer = new byte[10000];
                DatagramPacket packet = new DatagramPacket(buffer,buffer.length);
                socket.receive(packet);
                System.out.println("received");
                String msg = new String(packet.getData(),0,packet.getLength());
                System.out.println("Message reçu de "+ login +" : "+msg);
                if (msg.endsWith("end")){
                    break;
                }
            }
        }catch(IOException e){
            System.out.println("Error occurred while reading input: " + e.getMessage());
        } catch(Exception e){
            System.out.println("Error occurred while sending message: " + e.getMessage());

        }
    }
}`





`package Udp_version;

import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;

public class ThreadEnv extends Thread{
    DatagramSocket socket;
    InetAddress address;
    int port;
    ThreadEnv(DatagramSocket s, InetAddress addr,int p){
        socket = s;
        address = addr;
        port= p;
    }
    public void run() {
        try {
            while (true) {
                System.out.println("Saisir le message a envoyer : ");
                BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
                String msg = input.readLine();
                byte[] buffer = msg.getBytes(StandardCharsets.UTF_8);
                DatagramPacket packet = new DatagramPacket(buffer,buffer.length,address,port);
                socket.send(packet);
                System.out.println("sent");
                if (msg.equals("end")){
                    break;
                }
            }
        }catch(IOException e){
            System.out.println("Error occurred while reading input: " + e.getMessage());
        } catch(Exception e){
            System.out.println("Error occurred while sending message: " + e.getMessage());
            }finally {
            socket.close();
        }
        }

}`





`package Udp_version;

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

public class UdpChatServer {
    final static int port =1338;
    static Vector<DatagramSocket> tab_sec = new Vector<>();
    static Vector<String> tab_log = new Vector<>();
    public static void main(String[] args){
        try{
            DatagramSocket ds = new DatagramSocket(port);
            while (true) {
                byte[] buffer = new byte[10000];
                DatagramPacket packet = new DatagramPacket(buffer,buffer.length);
                System.out.println("en attente du login : ");
                ds.receive(packet);
                System.out.println("received00");
                String login = new String(packet.getData(),0,packet.getLength());
                UdpChatServer.tab_sec.add(ds);
                UdpChatServer.tab_log.add(login);
                System.out.println(UdpChatServer.tab_log);
                ServerThread s = new ServerThread(ds, ds.getInetAddress(), ds.getPort());
                s.start();
            }
        }catch(IOException e){
            System.out.println("Error occurred while reading input: " + e.getMessage());
        } catch(Exception e){
            System.out.println("Error occurred while sending message: " + e.getMessage());
        }

    }
}`





`package Udp_version;
import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;

public class ServerThread extends Thread {
    DatagramSocket datagramSocket;
    InetAddress address;
    int port;
    byte[] buffer;

    ServerThread(DatagramSocket datagramSocket, InetAddress address,int port) {
        this.datagramSocket = datagramSocket;
        this.address = address;
        this.port = port;
        buffer = new byte[10000];
    }

    public void run() {
        try {
            while (true) {
                System.out.println("en attente du choix du client : ");
                buffer = new byte[20000];
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
                datagramSocket.receive(packet);
                String choix = new String(packet.getData(), 0, packet.getLength());
                if (choix.equals("Lister")) {
                    System.out.println("Working01");
                    StringBuilder res = new StringBuilder();
                    for (int i = 0; i < UdpChatServer.tab_log.size(); i++) {
                        res.append(UdpChatServer.tab_log.get(i)).append(" ");
                    }
                    InetAddress destAddress = packet.getAddress();
                    int destPort = packet.getPort();
                    buffer = new byte[20000];
                    buffer = res.toString().getBytes(StandardCharsets.UTF_8);
                    packet = new DatagramPacket(buffer, buffer.length, destAddress, destPort);
                    datagramSocket.send(packet);
                    System.out.println("sent01");
                } else if (choix.equals("Se connecter")) {
                    System.out.println("Working02");
                    buffer = new byte[20000];
                    packet = new DatagramPacket(buffer, buffer.length);
                    datagramSocket.receive(packet);
                    String logcorrespondant = new String(packet.getData(), 0, packet.getLength());
                    int compteur = 0;
                    while ((compteur < UdpChatServer.tab_log.size()) && !(logcorrespondant.equals(UdpChatServer.tab_log.elementAt(compteur)))) {
                        compteur++;
                    }
                    if (compteur == UdpChatServer.tab_log.size()) {
                        System.out.println("login correspondant introuvable");
                    } else {
                        DatagramSocket clientSocket = new DatagramSocket();
                        InetAddress destAddress = packet.getAddress();
                        int destPort = packet.getPort();
                        System.out.println(destAddress);
                        System.out.println(destPort);
                        ThreadCntt th = new ThreadCntt(clientSocket, destAddress, destPort, UdpChatServer.tab_sec.elementAt(compteur));
                        th.start();
                    }
                }
            }
        } catch(IOException e){
            System.out.println("Error occurred while reading input: " + e.getMessage());
        } catch(Exception e){
            System.out.println("Error occurred while sending message: " + e.getMessage());
        }
    }
}`




`package Udp_version;

import java.io.*;
import java.net.*;


public class ThreadCntt extends Thread{
    DatagramSocket socket;
    InetAddress address;
    int port;
    DatagramSocket destSocket;
    byte[] buffer;
    DatagramPacket packet;
    ThreadCntt(DatagramSocket socket, InetAddress address, int port,DatagramSocket destSocket){
        this.socket = socket;
        this.address = address;
        this.port = port;
        this.destSocket = destSocket;
        buffer = new byte[10000];
        packet = new DatagramPacket(buffer,buffer.length);
    }
    public void run(){
        try {
            while(true){
                packet = new DatagramPacket(buffer,buffer.length);
                socket.receive(packet);
                System.out.println("received001");
                String msg = new String(packet.getData(),0, packet.getLength());
                if(msg.equals("end")){
                    break;
                }
                DatagramPacket sendPacket = new DatagramPacket(packet.getData(), packet.getLength(), destSocket.getInetAddress(), destSocket.getPort());
                destSocket.send(sendPacket);
                System.out.println("sent001");
                buffer = new byte[10000];
                packet = new DatagramPacket(buffer,buffer.length);
                destSocket.receive(packet);
                System.out.println("received001");
                msg = new String(packet.getData(),0,packet.getLength());
                System.out.println(msg);
            }
        }catch(IOException e){
            System.out.println("Error occurred while reading input: " + e.getMessage());
        } catch(Exception e){
            System.out.println("Error occurred while sending message: " + e.getMessage());
        }
    }
}`

服务器首先要求您登录，以便他可以将其添加到列表中。然后客户端收到一条消息，他必须在 1、2 和 0 之间进行选择：“列出所有连接的客户端”、“与另一个客户端通信”或“关闭线程”。

服务器应该能够根据客户端的输入处理这些动作：

如果客户端发送“1”，服务器应该响应连接的客户端列表。 如果客户端发送“2”，服务器应提示客户端输入他们希望向其发送消息的相应客户端的登录名。输入登录后，服务器应创建一个新线程来处理两个客户端之间的通信。

问题是，当第一个连接的客户端想要查看列表中的成员时，它起作用了，但是当第二个连接的客户端执行相同操作时，向量中添加了“Lister”一词，然后运行程序进入循环.此外，当客户端发送消息时，没有任何反应。

有人能帮帮我吗？