Блог

Мы создали программу для общения с сокетом на Java. Но у нас есть проблема, которая возникает, когда есть 2 или более участников чата. Если есть участники с именами A, B и C (введенные в алфавитном порядке), когда A (или B) покинул комнату, последний участник (C) покинул комнату с A (или B) без ошибок. Если есть участник D, предыдущий участник покидает комнату, последний участник (в данном случае участник D) покидает комнату с предыдущим участником без ошибок. Как мы можем это решить?

// Обработать эту ошибку//

A входит > B входит> C входит > D входит > A или B или C уходит (D тоже уходит, почему???) Только последний участник уходит с предыдущим участником

Сервер

 public class Server {
    public static final int PORT = 7777;
    private ServerSocket serverSocket;
    private Socket socket;
    private ServerGUI gui;
    private String msg;
    private int count = 0;
private int NMC=0;
    private Map<String, DataOutputStream> clientsMap = new HashMap<String, DataOutputStream>();
    public final void setGUI(ServerGUI gui) {
        this.gui = gui;
    }

    public void setting() throws IOException {

        Collections.synchronizedMap(clientsMap);

        serverSocket = new ServerSocket(PORT);
        String hostAddress = InetAddress.getLocalHost().getHostAddress();
        while (true) {
            System.out.println("waiting connection - "   hostAddress   ":"   PORT);
            socket = serverSocket.accept();
            System.out.println("connected from"   socket.getInetAddress());
            Receiver receiver = new Receiver(socket);
            receiver.start();
        }

    }

    public void addClient(String name, DataOutputStream out) throws IOException {

        clientsMap.put(name, out);
        sendMessage(name   "enteredn");
        gui.appendMsg(name   "enteredn");

        count  ;
        gui.appendMsg("joining member : "   count   "n");
    }

    public void sendMessage(String msg) {
        Iterator<String> member = clientsMap.keySet().iterator();
        String key = "";
        while (member.hasNext()) {
            key = member.next(); 
            try {
                clientsMap.get(key).writeUTF(msg);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    class Receiver extends Thread {
        private DataInputStream in;
        private DataOutputStream out;
        private String name;

        public Receiver(Socket socket) throws IOException {

            out = new DataOutputStream(socket.getOutputStream());
            in = new DataInputStream(socket.getInputStream());
            name = in.readUTF();

            if (count != 0) {
                NMC=NameMatch(name);

            }

            if (NMC == 1 || count == 0) {

                addClient(name, out);
            } else {

                out.writeUTF("not available");
                socket.close();
                out.close();
                in.close();
            }

        }

        public void run() {
            try {
                while (in != null) {
                    msg = in.readUTF();
                    sendMessage(msg);
                    gui.appendMsg(msg);
                }
            } catch (IOException e) {
                try {
                    if (NMC == 0) {
                        socket.close();
                        in.close();
                        out.close();
                        NMC  ;
                    } else {
                        socket.close();
                        in.close();
                        out.close();
                        clientsMap.remove(name);
                        count--;
                        gui.appendMsg(name   "has left.n");
                        gui.appendMsg("joining member : "   count   "n");
                        sendMessage(name   "has left.n");
                    }
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

    public int NameMatch(String name) {

        Iterator<String> member = clientsMap.keySet().iterator();
        String key = "";
        while (member.hasNext()) {
            int i = 0;
            if (i == count) {

                break;
            
            }else{

                key = member.next();
                if (key.equals(name)) {
                    return 0;
                }

            }
            i  ;
        }
        return 1;
    }

    public static void main(String[] args) throws IOException {
        Server server = new Server();
        server.setting();
    }
}
  

»’
Клиент

 package chat.client;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

import javax.swing.JOptionPane;

public class Client {

    private Socket socket;
    private DataInputStream in;
    private DataOutputStream out;
    private ClientGUI gui;
    private String msg;
    private String Name;
    private int PORT = 0;
    private String IP = "";
    
    public final void setGUI(ClientGUI gui) {
        this.gui = gui;
    }

    class connect extends Thread {

        public connect() {
            try {
                socket = new Socket(IP, PORT);
                System.out.println("Connected.");

                out = new DataOutputStream(socket.getOutputStream());
                in = new DataInputStream(socket.getInputStream());
                out.writeUTF(Name);

                if (in.readUTF().equals("not available")) {
                    out.close();
                    in.close();
                    socket.close();
                    JOptionPane.showMessageDialog(null, "not available");
                    System.exit(1);

                }

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

        public void run() {
            try {
                while (in != null) {
                    msg = in.readUTF();
                    gui.appendMsg(msg);
                }
            } catch (IOException e) {
                try {
                    out.close();
                    in.close();
                socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
                
            }
        }
    }

    public static void main(String[] args) throws IOException {
        Client client = new Client();
        client.setConnect();
    }

    public void setConnect() {
        connect c = new connect();
        c.start();
    }

    public void sendMessage(String msg) {
        try {
            out.writeUTF(msg);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void setNickname(String Name) {
        this.Name = Name;
    }

    public void Port(int port) {
        this.PORT = port;

    }

    public void Ip(String ip) {
        this.IP = ip;

    }

}
  

В Server.Receiver классе вы не сохраняете ссылку на клиентский сокет соединения. Это означает, что когда run метод закрывает сокет с:

 socket.close();
  

на самом деле используется socket переменная из содержащего Server класса, которая является подключением последнего подключившегося пользователя. Это означает, что при выходе любого из A, B или C D отключается.

Вы можете исправить это, просто удалив вызов socket.close() из Receiver.run метода. Сокет закрывается, когда вы закрываете связанный с ним поток ввода или вывода.

Советы по предотвращению подобных ошибок в будущем:

• Избегайте использования переменных экземпляра, когда можете. Если бы Server.socket была локальная переменная, ошибка была бы очевидна с самого начала, потому что в первую очередь не было бы переменной «socket», которую вы могли бы использовать.

   Socket socket = serverSocket.accept();
  System.out.println("connected from"   socket.getInetAddress());
  Receiver receiver = new Receiver(socket);
    

• Когда вы создаете вложенные классы, сначала предпочитайте создавать их static :

   static class Receiver extends Thread {
    

  Это предотвращает случайное использование экземпляра объекта enclosure. Вы всегда можете удалить модификатор «static», когда обнаружите, что вам нужно использовать экземпляр объекта enclosure.