java socket服务端 接收到断开连接

在Java Socket服务端中，当接收到客户端的断开连接请求时，通常是因为客户端关闭了TCP连接，或者是通过调用`Socket.close()`方法主动结束连接，或者是网络问题导致的数据传输中断。服务器通常会捕获到这样的事件，这通常是通过监听`Socket`对象的`close()`方法，或者注册一个`Inputstream`的异常处理器来检测。

当你从`Socket.getInputStream()`读取数据时，如果发生IOException，比如`EOFException`（End Of File），那可能是客户端已经关闭了连接。这时，可以检查异常并采取相应措施，例如：

try {
    byte[] buffer = new byte[1024];
    int bytesRead = is.read(buffer);
} catch (IOException e) {
    if (e instanceof EOFException) {
        System.out.println("Client disconnected.");
        // 关闭socket资源，释放连接
        socket.close();
    } else {
        // 处理其他类型的输入流错误
    }
}

在处理完客户端连接关闭的情况后，你应该记得将相关的资源（如`ServerSocket`、`Socket`等）适当地关闭，以释放系统资源并防止内存泄漏。

相关问题

java的客户端服务端Socket通信完整实例(心跳包,客户端断线重连,服务端超时断开客户端连接)代码

好的，下面是一个简单的 Java 客户端服务端 Socket 通信的完整实例，包括心跳包、客户端断线重连、服务端超时断开客户端连接的代码：

客户端代码：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class Client {
    private Socket socket;
    private InputStream inputStream;
    private OutputStream outputStream;
    private boolean connected = false;

    public void connect(String host, int port) {
        try {
            socket = new Socket(host, port);
            inputStream = socket.getInputStream();
            outputStream = socket.getOutputStream();
            connected = true;
            System.out.println("Connected to " + host + ":" + port);
        } catch (IOException e) {
            System.err.println("Failed to connect to " + host + ":" + port);
        }
    }

    public void disconnect() {
        try {
            if (socket != null && !socket.isClosed()) {
                socket.close();
                inputStream.close();
                outputStream.close();
                connected = false;
                System.out.println("Disconnected from server");
            }
        } catch (IOException e) {
            System.err.println("Failed to disconnect from server");
        }
    }

    public void send(String message) {
        try {
            outputStream.write(message.getBytes());
            outputStream.flush();
        } catch (IOException e) {
            System.err.println("Failed to send message");
        }
    }

    public void startHeartbeat() {
        Thread heartbeatThread = new Thread(() -> {
            while (connected) {
                send("heartbeat");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    System.err.println("Heartbeat thread interrupted");
                }
            }
        });
        heartbeatThread.start();
    }

    public void startReconnect() {
        Thread reconnectThread = new Thread(() -> {
            while (!connected) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    System.err.println("Reconnect thread interrupted");
                }
                System.out.println("Attempting to reconnect...");
                connect("localhost", 1234); // replace with actual host and port
            }
        });
        reconnectThread.start();
    }

    public void listen() {
        Thread listenThread = new Thread(() -> {
            byte[] buffer = new byte[1024];
            while (connected) {
                try {
                    int bytesRead = inputStream.read(buffer);
                    if (bytesRead > 0) {
                        String message = new String(buffer, 0, bytesRead);
                        System.out.println("Received message: " + message);
                    }
                } catch (IOException e) {
                    System.err.println("Failed to read message");
                    disconnect();
                }
            }
        });
        listenThread.start();
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.connect("localhost", 1234); // replace with actual host and port
        client.startHeartbeat();
        client.startReconnect();
        client.listen();
    }
}

服务端代码：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private ServerSocket serverSocket;
    private boolean running = false;

    public void start(int port) {
        try {
            serverSocket = new ServerSocket(port);
            running = true;
            System.out.println("Server started on port " + port);
            while (running) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getInetAddress().getHostAddress());
                handleClient(clientSocket);
            }
        } catch (IOException e) {
            System.err.println("Failed to start server");
        }
    }

    public void stop() {
        try {
            if (serverSocket != null && !serverSocket.isClosed()) {
                serverSocket.close();
                running = false;
                System.out.println("Server stopped");
            }
        } catch (IOException e) {
            System.err.println("Failed to stop server");
        }
    }

    private void handleClient(Socket clientSocket) {
        Thread clientThread = new Thread(() -> {
            try {
                InputStream inputStream = clientSocket.getInputStream();
                OutputStream outputStream = clientSocket.getOutputStream();
                byte[] buffer = new byte[1024];
                while (true) {
                    int bytesRead = inputStream.read(buffer);
                    if (bytesRead > 0) {
                        String message = new String(buffer, 0, bytesRead);
                        System.out.println("Received message from client: " + message);
                        if (message.equals("heartbeat")) {
                            continue;
                        }
                        outputStream.write(("You said: " + message).getBytes());
                        outputStream.flush();
                    }
                }
            } catch (IOException e) {
                System.err.println("Failed to handle client");
            } finally {
                try {
                    clientSocket.close();
                    System.out.println("Client disconnected: " + clientSocket.getInetAddress().getHostAddress());
                } catch (IOException e) {
                    System.err.println("Failed to close client socket");
                }
            }
        });
        clientThread.start();
    }

    public static void main(String[] args) {
        Server server = new Server();
        server.start(1234); // replace with actual port
    }
}

在客户端代码中，`connect()` 方法用于连接服务器，`disconnect()` 方法用于断开连接，`send()` 方法用于发送消息，`startHeartbeat()` 方法用于启动心跳包发送线程，`startReconnect()` 方法用于启动断线重连线程，`listen()` 方法用于启动消息接收线程。在服务端代码中，`start()` 方法用于启动服务器，`stop()` 方法用于停止服务器，`handleClient()` 方法用于处理客户端连接。注意在客户端代码中，心跳包的发送间隔为 5 秒，断线重连的间隔也为 5 秒，这些时间间隔可以根据实际情况进行调整。

Java的Socket通信完整实例(心跳包,客户端断线重连,服务端超时断开客户端连接)

好的，下面是一个Java的Socket通信完整实例，包括心跳包、客户端断线重连和服务端超时断开客户端连接的处理。

首先，我们需要定义一些常量和变量：

private static final int SERVER_PORT = 8888; // 服务器端口
private static final String SERVER_HOST = "127.0.0.1"; // 服务器地址
private static final int HEARTBEAT_INTERVAL = 5000; // 心跳包间隔时间，单位：毫秒
private static final int RECONNECT_INTERVAL = 5000; // 断线重连间隔时间，单位：毫秒
private static final int TIMEOUT = 20000; // 超时时间，单位：毫秒

private Socket socket; // Socket对象
private BufferedReader reader; // 读取器
private PrintWriter writer; // 写入器
private Timer heartbeatTimer; // 心跳包定时器
private Timer reconnectTimer; // 断线重连定时器
private volatile boolean isConnecting = false; // 是否正在连接
private volatile boolean isConnected = false; // 是否已连接

然后，我们需要定义一些方法：

/**
 * 创建Socket连接
 */
private void createSocket() {
    try {
        socket = new Socket();
        socket.connect(new InetSocketAddress(SERVER_HOST, SERVER_PORT), TIMEOUT);
        reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        writer = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
        isConnected = true;
        startHeartbeat(); // 开始心跳包
    } catch (IOException e) {
        e.printStackTrace();
        isConnected = false;
        startReconnect(); // 开始断线重连
    }
}

/**
 * 发送数据
 * @param data 数据
 */
private void sendData(String data) {
    if (isConnected) {
        writer.println(data);
        writer.flush();
    }
}

/**
 * 接收数据
 * @return 数据
 */
private String receiveData() {
    String data = null;
    if (isConnected) {
        try {
            data = reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            isConnected = false;
            startReconnect(); // 开始断线重连
        }
    }
    return data;
}

/**
 * 开始心跳包
 */
private void startHeartbeat() {
    if (heartbeatTimer != null) {
        heartbeatTimer.cancel();
    }
    heartbeatTimer = new Timer();
    heartbeatTimer.schedule(new TimerTask() {
        @Override
        public void run() {
            sendData("heartbeat"); // 发送心跳包
        }
    }, 0, HEARTBEAT_INTERVAL);
}

/**
 * 开始断线重连
 */
private void startReconnect() {
    if (!isConnecting && !isConnected) {
        reconnectTimer = new Timer();
        reconnectTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                if (!isConnected) {
                    isConnecting = true;
                    createSocket(); // 创建Socket连接
                    isConnecting = false;
                } else {
                    reconnectTimer.cancel();
                }
            }
        }, RECONNECT_INTERVAL);
    }
}

/**
 * 关闭Socket连接
 */
private void closeSocket() {
    try {
        if (socket != null) {
            socket.close();
        }
        if (reader != null) {
            reader.close();
        }
        if (writer != null) {
            writer.close();
        }
        if (heartbeatTimer != null) {
            heartbeatTimer.cancel();
        }
        if (reconnectTimer != null) {
            reconnectTimer.cancel();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

/**
 * 监听连接状态
 */
private void listenConnectionState() {
    new Thread(new Runnable() {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (isConnected) {
                    try {
                        socket.sendUrgentData(0xFF); // 发送紧急数据，测试连接状态
                    } catch (IOException e) {
                        e.printStackTrace();
                        isConnected = false;
                        startReconnect(); // 开始断线重连
                    }
                }
            }
        }
    }).start();
}

最后，我们编写一个测试方法：

public static void main(String[] args) {
    SocketClient client = new SocketClient();
    client.createSocket(); // 创建Socket连接
    client.listenConnectionState(); // 监听连接状态
    while (true) {
        String data = client.receiveData();
        if (data != null) {
            System.out.println("收到数据：" + data);
        }
    }
}

这样，我们就完成了一个Java的Socket通信完整实例，包括心跳包、客户端断线重连和服务端超时断开客户端连接的处理。