Java 多客户端聊天服务器在断开连接后引发异常并不允许连接

很难将其放在标题中，但每次客户端断开连接时，都会引发大量异常，并且服务器不允许在DC之后再进行任何连接。以下是我得到的错误：

java.net.SocketException: Socket closed
at java.net.SocketInputStream.read(Unknown Source)
at java.net.SocketInputStream.read(Unknown Source)
at java.io.ObjectInputStream$PeekInputStream.read(Unknown Source)
at java.io.ObjectInputStream$PeekInputStream.readFully(Unknown Source)
at java.io.ObjectInputStream$BlockDataInputStream.readShort(Unknown Source)
at java.io.ObjectInputStream.readStreamHeader(Unknown Source)
at java.io.ObjectInputStream.<init>(Unknown Source)
at ClientHandler.setupStreams(ClientHandler.java:34)
at ClientHandler.run(ClientHandler.java:22)

java.net.SocketException:套接字已关闭
位于java.net.SocketInputStream.read（未知源）
位于java.net.SocketInputStream.read（未知源）
位于java.io.ObjectInputStream$PeekInputStream.read（未知源）
在java.io.ObjectInputStream$PeekInputStream.readFully处（未知源）
位于java.io.ObjectInputStream$BlockDataInputStream.readShort（未知源）
位于java.io.ObjectInputStream.readStreamHeader（未知源）
位于java.io.ObjectInputStream。（未知源）
位于ClientHandler.setupStreams（ClientHandler.java:34）
运行（ClientHandler.java:22）

现在我希望得到这个例外，因为是的。。。客户端关闭了服务器和客户端之间的连接。但我不明白的是，为什么客户端在第一次断开连接后不允许连接。我假设它打破了while循环，但为什么呢？下面是获取客户端连接、接受它并将其交给处理程序类的代码：

public class ClientConnector
{
public static JTextField userText;
public static JTextArea chatWindow;
public static int Connections = 0;
public static Vector sendQueue = new Vector();
public static ArrayList<ObjectOutputStream> Streams = new ArrayList<ObjectOutputStream>();
public static Scanner input = new Scanner(System.in);


public ClientConnector()
{

}

public static void runServer()
{
    try
    {   
        System.out.println("[Info] Attempting to bind to port 1337.");
        @SuppressWarnings("resource")
        ServerSocket serversocket = new ServerSocket(1337);
        System.out.println("[Info] Bound to port 1337.");
        System.out.println("[Info] Waiting for client connections...");
        while(true)
        {
            Socket socket = serversocket.accept();
            new ClientHandler(socket).start();
            Connections += 1;


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

公共类ClientConnector
{
公共静态JTextField userText；
公共区域聊天窗口；
公共静态int连接=0；
公共静态向量sendQueue=新向量（）；
公共静态ArrayList Streams=新ArrayList（）；
公共静态扫描仪输入=新扫描仪（System.in）；
公共客户端连接器（）
{
}
公共静态void runServer（）
{
尝试
{   
System.out.println（“[Info]试图绑定到端口1337”）；
@抑制警告（“资源”）
ServerSocket ServerSocket=新的ServerSocket（1337）；
System.out.println（“[Info]绑定到端口1337”）；
System.out.println（“[Info]正在等待客户端连接…”）；
while（true）
{
Socket=serversocket.accept（）；
新的ClientHandler（socket.start（）；
连接数+=1；
}
}
捕获（IOE异常）
{
e、 printStackTrace（）；
}
}
}

这相当简单。现在来看处理客户端连接的代码：

public class ClientHandler extends Thread
{
Socket ConnectedClient;
static ObjectOutputStream Output;
static ObjectInputStream Input;
public static boolean isError = false;
public static int updateCounter = 0;

ClientHandler(Socket socket)
{
    ConnectedClient = socket;
}

public void run()
{

    while(true)
    {
        setupStreams();//22
        WhileChatting();
    }
}

public void setupStreams()
{
    try 
    {
        if(isError == false)
        {
            Output = new ObjectOutputStream(ConnectedClient.getOutputStream());
            Input = new ObjectInputStream(ConnectedClient.getInputStream());//34
            ClientConnector.Streams.add(Output);
        }   
    }
    catch (IOException e)
    {
        isError = true;
        e.printStackTrace();
    }

}


public static void WhileChatting()
{
    String Message = "";
    do
    {
        try
        {
            if(isError == false)
            {
                Message = (String)Input.readObject();
                for(int i = 0; i < ClientConnector.Streams.size(); i++)
                {
                    ClientConnector.Streams.get(i).writeObject(Message);
                    System.out.println(Message);
                }
            }

        }
        catch(ClassNotFoundException CNFE)
        {
            isError = true;
            CNFE.printStackTrace();
        }
        catch(EOFException eof)
        {
            for(int i = 0; i < ClientConnector.Streams.size(); i++)
            {
                try
                {
                    Output.close();
                    Input.close();
                    ClientConnector.Streams.get(i).close();
                    ClientConnector.Streams.remove(i);
                    System.out.println("Connection lost");
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }

            }
        }
        catch (IOException e)
        {
            isError = true;
            e.printStackTrace();
        }

    }
    while(Message != "/disconnect");
}

public static void sendMessage(String message)
{
    try
    {
        if(isError == false)
        {
            Output.writeObject(message);
            System.out.println(message);
        }
    }
    catch(IOException Ex)
    {
        isError = true;
        Ex.printStackTrace();
    }
}

public static void sendServerMessage(String message)
{
    int Limit = 0;
    try
    {
        for(int i = 0; i < ClientConnector.Streams.size(); i++)
        {
            if(Limit == 0)
            {
                ClientConnector.Streams.get(i).writeObject("\247c[Server] \247d" + message);
                System.out.println("\247c[Server] \247d" + message);
                Limit = 1;
            }
        }
    }
    catch (IOException e)
    {
        e.printStackTrace();
    }
}

public static void closeConnections()
{
    try
    {
        if(isError == false)
        {
            Output.close();
            Input.close();
            //ConnectedClient.close();
        }
    }
    catch(IOException Ex)
    {
        isError = true;
        Ex.printStackTrace();
    }
}

}

public类ClientHandler扩展线程
{
套接字连接客户端；
静态ObjectOutputStream输出；
静态对象输入流输入；
公共静态布尔isError=false；
公共静态int updateCounter=0；
夹持器（插座）
{
ConnectedClient=socket；
}
公开募捐
{
while（true）
{
setupStreams（）；//22
WhileChatting（）；
}
}
公共数据流（）
{
尝试
{
if（isError==false）
{
Output=newObjectOutputStream（ConnectedClient.getOutputStream（））；
Input=new ObjectInputStream（ConnectedClient.getInputStream（））；//34
ClientConnector.Streams.add（输出）；
}   
}
捕获（IOE异常）
{
isError=真；
e、 printStackTrace（）；
}
}
填充时的公共静态无效（）
{
字符串消息=”；
做
{
尝试
{
if（isError==false）
{
Message=（字符串）Input.readObject（）；
对于（int i=0；i

我已经在受影响的行中发表了评论。 该错误发生在客户端断开连接之后。我不知道是异常导致while循环中断还是其他原因。如何使此代码在客户端断开连接后继续允许传入Connections。我尝试过调试和使用System.out.println。提前感谢所有回答的人

现在我希望得到这个例外，因为是的。。。客户端关闭了服务器和客户端之间的连接

否。此异常表示您关闭了

Soc