Question

我想检查一下我的客户是否已经断开连接。从我的研究中，可能的方法是我可以继续向客户写信息。如果客户端无法接收消息，则表示已断开连接。我发送消息＆＃34;检查连接：客户端＆＃34; + clientNo＆＃34;给各自的客户。

我将clientNo 1连接到服务器并收到

客户端1

"Checking Connection: Client1" <-- output every 10secs
"Checking Connection: Client1" <-- output every 10secs
"Checking Connection: Client1" <-- output every 10secs

但是当我将另一个客户端连接到服务器时，我的clientNo1 停止从服务器接收消息，我的clientNo2现在将接收

Client2

"Checking Connection: Client2"  <-- output every 10secs    
"Checking Connection: Client1"  <-- output every 10secs
"Checking Connection: Client2"  <-- output every 10secs    
"Checking Connection: Client1"  <-- output every 10secs

期望的输出

Client1

"Checking Connection: Client1" <-- output every 10secs 
"Checking Connection: Client1" <-- output every 10secs 
"Checking Connection: Client1" <-- output every 10secs

Client2

"Checking Connection: Client2" <-- output every 10secs 
"Checking Connection: Client2" <-- output every 10secs 
"Checking Connection: Client2" <-- output every 10secs

请帮忙。谢谢。

Server.java

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private int portNo = 0;
    private ObjectOutputStream out;
    private ObjectInputStream in;
    private boolean clientAlive = true;

    @SuppressWarnings("resource")
    public Server(int portNo) {
        Socket socket = null;
        this.portNo = portNo;
        ServerSocket sSocket = null;
        int clientNo = 1;
        try {
            sSocket = new ServerSocket(this.portNo);
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        while(true) {
            try {
                socket = sSocket.accept();
            } catch (IOException e) {
                e.printStackTrace();
            }
             new Thread(new acceptClient(socket,clientNo)).start();
             clientNo += 1;
        }
    }

    class acceptClient implements Runnable {
        Socket socket;
        int clientNo = 1;
        String writeToClient = "";

        public acceptClient(Socket socket, int clientNo) {
            this.socket = socket;
            this.clientNo = clientNo;
        }

        public void run() {
            try {
                out = new ObjectOutputStream(socket.getOutputStream());
                in = new ObjectInputStream(socket.getInputStream());
            } catch(IOException exception) {
                System.out.println("Error: " + exception);
            }

            while(clientAlive) {
                writeToClient = "Checking Connection: Client" + clientNo;
                sendData(out, writeToClient.getBytes());

                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(!clientAlive) {
                    break;
                }

            }
        }
    }

    public synchronized void sendData(ObjectOutputStream os, byte[] byteData) {
        if (byteData == null) {
            return;
        }
        try {
            os.write(byteData);
            os.flush();
        }
        catch (Exception e) {
            System.out.println("Client Disconnected");
            clientAlive = false;
        }
    }

    public static void main(String[] args) {
        System.out.println("Server started");
        new Server(5550);
    }
}

Client.java

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

import javax.swing.JDialog;
import javax.swing.JOptionPane;


public class Client {
    public static void main(String args[]) {
        clientConnection();
    }

    public static void clientConnection() {
        Socket clientSocket = null;
        ObjectOutputStream out = null;
        ObjectInputStream in = null;

        try {
            clientSocket = new Socket("localhost", 5550);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } 

        try {
            out = new ObjectOutputStream(clientSocket.getOutputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }   

        try {
            in = new ObjectInputStream(clientSocket.getInputStream());

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

        byte[] byteData = null;
        while(true) {
            try {
                byteData = receive(in);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(new String(byteData));
        }
    }

    public static byte[] receive(ObjectInputStream is) throws Exception {
        try {
            byte[] inputData = new byte[1024];
            is.read(inputData);
            return inputData;
        }
        catch (Exception exception) {
            throw exception;
        }
    }
}

Answer 1

您的ObjectInputStream和ObjectOutputStream是Server课程的一部分。让他们成为acceptClient类的成员，它应该没问题。

java tcp套接字检查客户端断开连接

1 个答案: