Java网络编程：TCP连接异常处理示例

原创秒速五厘米 2024-12-07 11:54 37阅读 0赞

在Java的网络编程中，TCP连接异常是常见的问题。这种异常通常是由网络中断、服务器关闭等原因引起的。以下是一个简单的示例，演示如何捕获并处理这些异常：

```java
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(1234)) {
            System.out.println("Server is listening on port 1234...");

while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected from IP: " + clientSocket.getInetAddress().getHostAddress());

// 创建一个新的线程来处理客户端的输入输出
                new Thread(() -> handleClient(clientSocket))).start();
            }
        } catch (IOException e) {
            System.err.println("Error occurred while listening to the server socket: " + e.getMessage());
            e.printStackTrace();
        }
    }

private static void handleClient(Socket clientSocket) {
        try (Socket clientOutputSocket = new Socket("localhost", 5000)) {
            // 创建连接到另一个服务器的客户端套接字
            System.out.println("Opening a connection to the 'echo' server on port 5000...");

// 将客户端的输出流重定向到另一个服务器
            Thread threadClientOutput = new Thread(() -> {
                try (java.io.DataOutputStream out = new DataOutputStream(clientOutputSocket.getOutputStream()))) {
                    // 在客户端向目标服务器发送数据时，处理数据格式
                    String dataToEcho = "Hello, Server! This is a test message from the client..."; // Replace with your actual data
                    byte[] bytesDataToEcho = dataToEcho.getBytes("utf-8"); // Convert to UTF-8 for compatibility

out.writeBytes(bytesDataToEcho);
                    System.out.println("Sent: " + new String(bytesDataToEcho), "UTF-8"));

// 接收目标服务器的响应数据
                    byte[] bytesResponseFromServer = new byte[1024]; // Buffer size to receive server response
                    int lengthReceivedServerResponse = clientOutputSocket.getInputStream().read(bytesResponseFromServer));

System.out.println("Received: " + new String(bytesResponseFromServer), "UTF-8"));

} catch (IOException e) {
                    System.err.println("Error occurred while reading/writing from/to the sockets: " + e.getMessage());
                    e.printStackTrace();
                }
            })}.start();

// 在客户端将输入流重定向到与目标服务器的连接
            Thread threadClientInput = new Thread(() -> {
                try (java.io.DataInputStream in = new DataInputStream(clientSocket.getInputStream()))) {
                    byte[] bytesMessageFromServer = new byte[1024]; // Buffer size to receive server message

System.out.println("Waiting for a message from the server...");

int lengthReceivedServerMessage = in.read(bytesMessageFromServer));

if (lengthReceivedServerMessage > 0) {
                        System.out.println("Received message from the server: " + new String(bytesMessageFromServer), "UTF-8"));

// 在客户端处理接收到的服务器消息
                        processServerMessage(bytesMessageFromServer));
                    }
                } catch (IOException e) {
                    System.err.println("Error occurred while reading/writing from/to the sockets: " + e.getMessage());
                    e.printStackTrace();
                }
            })}.start();

// 永远循环，处理客户端和目标服务器之间的连接
        while (true) {
            try {
                Thread.sleep(1000); // Sleep for 1 second to avoid CPU usage
            } catch (InterruptedException e) {
                System.err.println("Error occurred while sleeping: " + e.getMessage());
                e.printStackTrace();
            }
            // 如果客户端已经关闭连接，删除它并继续处理其他客户端
            if (!clientSocket.isConnectionPossible()) {
                System.out.println("Client connection was closed, removing it from the list...");
                clientSocketList.remove(clientSocket);
            }

// 遍历客户端列表，检查每个客户端是否已连接到目标服务器
            for (Socket client : clientSocketList) {
                if (!client.isConnectionPossible())) { // If client is disconnected, skip it
                    continue;
                }
                try {
                    // 如果客户端已经连接到目标服务器，处理其数据传输
                    byte[] bytesMessageFromClient = new byte[1024]; // Buffer size to receive server message

System.out.println("Waiting for a message from the client...");

int lengthReceivedServerMessage = client.getInputStream().read(bytesMessageFromClient));

if (lengthReceivedServerMessage > 0) {
                        System.out.println("Received message from the client: " + new String(bytesMessageFromClient), "UTF-8"));

// 在客户端处理接收到的客户端消息
                        processClientMessage(bytesMessageFromClient));
                    }
                } catch (IOException e) {
                    System.err.println("Error occurred while reading/writing from/to the sockets: " + e.getMessage());
                    e.printStackTrace();
                }
            }

}
    }

private static void processServerMessage(byte[] bytesMessageFromServer) {
        // 在这里实现处理接收到的服务器消息的具体逻辑
        String messageFromServer = new String(bytesMessageFromServer), "UTF-8");

System.out.println("Received server message: " + messageFromServer));

// 这里只是一个示例，实际应用中可以将消息发送到客户端或其他系统
        sendClientMessage(messageFromServer));
    }

private static void processClientMessage(byte[] bytesMessageFromClient) {
        // 在这里实现处理接收到的客户端消息的具体逻辑
        String messageFromClient = new String(bytesMessageFromClient), "UTF-8");

System.out.println("Received client message: " + messageFromClient));

// 这里只是一个示例，实际应用中可以将消息发送到服务器或其他系统
        sendServerMessage(messageFromClient));
    }

private static void sendClientMessage(String messageFromServer) {
        try (Socket socket = new Socket("localhost", 6001));) {
            DataOutputStream out = new DataOutputStream(socket.getOutputStream()));

// 将消息转换为字节数组
            byte[] bytesMessageToSend = messageFromServer.getBytes("utf-8");

// 写入消息到输出流
            out.write(bytesMessageToSend));

// 关闭数据输出流
            out.close();

System.out.println("Sent client message to the server: " + messageFromServer));

} catch (IOException e) {
            System.err.println("Error occurred while sending the client message to the server: " + e.getMessage());
            e.printStackTrace();
        }
    }

private static void sendServerMessage(String messageFromClient) {
        try (Socket socket = new Socket("localhost", 6001));) {
            DataOutputStream out = new DataOutputStream(socket.getOutputStream()));

// 将消息转换为字节数组
            byte[] bytesMessageToSend = messageFromClient.getBytes("utf-8");

// 写入消息到输出流
            out.write(bytesMessageToSend));

// 关闭数据输出流
            out.close();

System.out.println("Sent server message to the client: " + messageFromClient));

} catch (IOException e) {
            System.err.println("Error occurred while sending the server message to the client: " + e.getMessage());
            e.printStackTrace();
        }
    }
}
```

这个示例中，我们创建了一个TCP服务器，它监听6001端口。当客户端连接到服务器时，它将接收到的客户端消息发送回客户端。

同时，我们还创建了一个客户端，它可以向服务器发送消息。当服务器接收到消息后，它会将响应消息发送回客户端。

注意：这个示例需要在一个支持Java网络编程环境（如Eclipse或IntelliJ IDEA）中运行，且两台机器都需要开启监听6001端口的TCP服务。