Java TCP通信：实现连续数据读取与“停止”机制-java教程-PHP中文网

Java TCP通信：实现连续数据读取与“停止”机制

本文详细探讨了Java中基于TCP协议的客户端-服务器通信中，如何使用BufferedReader实现连续数据读取，并处理特定的“停止”指令以优雅地终止连接。文章分析了初始代码中单次读取的问题，并提供了优化后的服务器和客户端代码示例，通过引入内部循环和空值检测，实现了灵活的数据交换和连接管理，同时强调了资源关闭和异常处理的重要性。

理解TCP长连接中的数据读取挑战

在java中构建基于tcp的客户端-服务器应用程序时，实现连续的数据传输和接收是常见的需求。特别是当需要客户端发送多条消息，并且服务器持续处理这些消息直到收到特定的“停止”指令时，对bufferedreader的正确使用和连接管理变得尤为关键。

原始的代码示例展示了一个简单的TCP通信模型：客户端发送一行文本，服务器接收并将其转换为大写后返回。然而，该实现存在一个问题：服务器在处理完一行数据后，会断开与当前客户端的逻辑连接（尽管物理连接可能未完全关闭），并等待新的客户端连接。这导致客户端只能发送和接收一次数据，无法实现连续的交互。

原始代码分析与存在的问题

让我们先回顾一下原始的客户端和服务器代码，并分析其局限性。

原始客户端代码：

import java.io.*;
import java.net.*;

public class Klient {
    public static void main(String[] args) throws UnknownHostException, IOException {
        String sentence;
        String modifiedSentence;
        BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
        Socket clientSocket = new Socket("127.0.0.1", 6789);
        DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());
        BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

        while (true){ // 客户端循环发送和接收
            sentence = inFromUser.readLine();
            outToServer.writeBytes(sentence + '\n');
            modifiedSentence = inFromServer.readLine(); // 等待服务器响应
            System.out.println(modifiedSentence);
        }
        // clientSocket.close(); // 缺少关闭操作
    }
}

登录后复制

原始服务器代码：

立即学习“Java免费学习笔记（深入）”；

import java.io.*;
import java.net.*;

public class TCPServer {
    public static void main(String[] args) throws IOException {
        String clientSentence;
        String capitalizedSentence;
        ServerSocket welcomeSocket = new ServerSocket(6789);

        while (true){ // 外部循环等待新连接
            Socket connectionSocket = welcomeSocket.accept(); // 接受一个新连接
            BufferedReader inFromClient = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
            DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());

            clientSentence = inFromClient.readLine(); // 从客户端读取一行
            capitalizedSentence = clientSentence.toUpperCase() + '\n';
            outToClient.writeBytes(capitalizedSentence);
            // 循环结束后，connectionSocket 未被显式关闭，但会隐式失效，服务器继续等待新连接
        }
    }
}

登录后复制

问题所在：

服务器端的while (true)循环实际上是用于接受新的客户端连接，而不是处理来自单个客户端的连续输入。一旦welcomeSocket.accept()接受了一个连接，服务器会从该连接读取一行数据并发送响应，然后循环回到welcomeSocket.accept()，等待下一个客户端。这意味着对于同一个客户端，服务器只处理一次交互。

为了实现单个客户端的连续通信，我们需要在接受连接后，为该连接引入一个内部循环来持续读取数据。

解决方案：实现连续数据读取与“停止”机制

要解决这个问题，我们需要对服务器和客户端的代码进行修改，以支持长连接中的多行数据传输，并引入一个“停止”命令来控制通信的终止。

1. 服务器端代码优化

服务器需要一个内部循环来持续从当前连接读取数据，直到收到“停止”指令或连接关闭。

腾讯智影-AI数字人

基于AI数字人能力，实现7*24小时AI数字人直播带货，低成本实现直播业务快速增增，全天智能在线直播

查看详情

修改后的服务器代码示例：

import java.io.*;
import java.net.*;

public class TCPServer {
    public static void main(String[] args) throws IOException {
        String clientSentence;
        String capitalizedSentence;
        ServerSocket welcomeSocket = new ServerSocket(6789);
        System.out.println("服务器已启动，等待客户端连接...");

        while (true) { // 外部循环：接受新的客户端连接
            Socket connectionSocket = welcomeSocket.accept(); // 接受一个新连接
            System.out.println("客户端 " + connectionSocket.getInetAddress() + ":" + connectionSocket.getPort() + " 已连接。");

            try (BufferedReader inFromClient = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
                 DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream())) {

                while (true) { // 内部循环：处理当前客户端的连续输入
                    clientSentence = inFromClient.readLine(); // 从客户端读取一行数据

                    if (clientSentence == null) {
                        // 客户端已关闭连接（发送EOF）
                        System.out.println("客户端 " + connectionSocket.getInetAddress() + ":" + connectionSocket.getPort() + " 已断开连接。");
                        break; // 退出内部循环，等待新的客户端连接
                    }

                    if (clientSentence.equalsIgnoreCase("stop")) {
                        // 收到“stop”指令，关闭当前客户端连接
                        System.out.println("收到 'stop' 指令，关闭与客户端 " + connectionSocket.getInetAddress() + ":" + connectionSocket.getPort() + " 的连接。");
                        break; // 退出内部循环，等待新的客户端连接
                    }

                    capitalizedSentence = clientSentence.toUpperCase() + '\n';
                    outToClient.writeBytes(capitalizedSentence);
                    System.out.println("收到: " + clientSentence + ", 发送: " + capitalizedSentence.trim());
                }
            } catch (IOException e) {
                System.err.println("处理客户端 " + connectionSocket.getInetAddress() + ":" + connectionSocket.getPort() + " 时发生错误: " + e.getMessage());
            } finally {
                // 确保在内部循环结束后关闭当前连接的Socket
                if (connectionSocket != null && !connectionSocket.isClosed()) {
                    connectionSocket.close();
                }
            }
        }
        // welcomeSocket.close(); // 如果服务器需要完全终止，则在此处关闭
    }
}

登录后复制

主要改进点：

内部循环 (while(true)): 在welcomeSocket.accept()之后，引入了一个新的while(true)循环。这个内部循环负责持续从同一个connectionSocket读取数据。
“stop”指令处理: 当inFromClient.readLine()读取到“stop”时（不区分大小写），服务器会关闭当前的connectionSocket，并通过break语句跳出内部循环。这样，外部循环就可以继续等待下一个客户端连接。
检测客户端断开: BufferedReader.readLine()在流的末尾（即客户端关闭其输出流）时会返回null。服务器通过检查clientSentence == null来判断客户端是否已正常断开连接，并相应地退出内部循环。
资源管理 (try-with-resources): 使用try-with-resources语句确保BufferedReader和DataOutputStream在不再需要时（无论是否发生异常）自动关闭，避免资源泄露。
显式关闭 connectionSocket: 在finally块中显式关闭connectionSocket，确保每次客户端连接处理完毕后，相关资源得到释放。

服务器完全终止的场景：

如果服务器在处理完一个客户端后需要完全终止（即不再接受新的连接），可以移除外部的while(true)循环，并在处理完客户端后关闭welcomeSocket。

import java.io.*;
import java.net.*;

public class TCPServerSingleClient {
    public static void main(String[] args) throws IOException {
        String clientSentence;
        String capitalizedSentence;
        ServerSocket welcomeSocket = new ServerSocket(6789);
        System.out.println("服务器已启动，等待一个客户端连接...");

        Socket connectionSocket = null;
        try {
            connectionSocket = welcomeSocket.accept(); // 接受一个新连接
            System.out.println("客户端 " + connectionSocket.getInetAddress() + ":" + connectionSocket.getPort() + " 已连接。");

            try (BufferedReader inFromClient = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
                 DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream())) {

                while (true) { // 内部循环：处理当前客户端的连续输入
                    clientSentence = inFromClient.readLine();

                    if (clientSentence == null || clientSentence.equalsIgnoreCase("stop")) {
                        System.out.println("收到 'stop' 指令或客户端断开，关闭连接。");
                        break;
                    }

                    capitalizedSentence = clientSentence.toUpperCase() + '\n';
                    outToClient.writeBytes(capitalizedSentence);
                    System.out.println("收到: " + clientSentence + ", 发送: " + capitalizedSentence.trim());
                }
            }
        } catch (IOException e) {
            System.err.println("处理客户端时发生错误: " + e.getMessage());
        } finally {
            if (connectionSocket != null && !connectionSocket.isClosed()) {
                connectionSocket.close(); // 关闭客户端连接
            }
            if (welcomeSocket != null && !welcomeSocket.isClosed()) {
                welcomeSocket.close(); // 关闭服务器监听端口
                System.out.println("服务器已关闭。");
            }
        }
    }
}

登录后复制

2. 客户端代码优化

客户端需要能够检测服务器何时关闭了连接（例如，服务器收到“stop”指令后），以便客户端也能优雅地终止其发送/接收循环。

修改后的客户端代码示例：

import java.io.*;
import java.net.*;

public class Klient {
    public static void main(String[] args) throws UnknownHostException, IOException {
        String sentence;
        String modifiedSentence;
        BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
        Socket clientSocket = null; // 初始化为null，便于finally块处理

        try {
            clientSocket = new Socket("127.0.0.1", 6789);
            System.out.println("已连接到服务器。输入消息，输入 'stop' 终止连接。");

            DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());
            BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

            while (true) {
                System.out.print("请输入消息: ");
                sentence = inFromUser.readLine(); // 从用户读取输入

                if (sentence == null) { // 用户输入EOF，通常通过Ctrl+D/Z
                    System.out.println("用户输入流已关闭。");
                    break;
                }

                outToServer.writeBytes(sentence + '\n'); // 发送消息到服务器

                if (sentence.equalsIgnoreCase("stop")) {
                    // 如果发送了“stop”指令，客户端也应准备终止
                    System.out.println("已发送 'stop' 指令。等待服务器响应并关闭连接...");
                    // 服务器可能会先关闭，导致readLine返回null
                }

                modifiedSentence = inFromServer.readLine(); // 等待服务器响应

                if (modifiedSentence == null) {
                    // 服务器已关闭连接，readLine返回null
                    System.out.println("服务器已关闭连接。");
                    break; // 退出循环
                }
                System.out.println("服务器响应: " + modifiedSentence);
            }
        } catch (IOException e) {
            System.err.println("客户端通信发生错误: " + e.getMessage());
        } finally {
            // 确保客户端Socket在任何情况下都关闭
            if (clientSocket != null && !clientSocket.isClosed()) {
                clientSocket.close();
                System.out.println("客户端连接已关闭。");
            }
        }
    }
}

登录后复制

主要改进点：

检测服务器关闭 (modifiedSentence == null): 当服务器端关闭其connectionSocket时（例如，收到“stop”指令后），客户端的inFromServer.readLine()将返回null。客户端通过检测这个null值来判断服务器已断开连接，并相应地退出其发送/接收循环。
“stop”指令发送: 客户端发送“stop”指令后，其行为与发送其他消息相同，但它应该预期服务器会因此关闭连接。
资源管理 (try-finally): 客户端也应确保clientSocket在程序结束或发生异常时得到关闭，防止资源泄露。

注意事项与最佳实践

资源关闭: 在网络编程中，Socket、ServerSocket以及相关的输入/输出流都是宝贵的系统资源。务必在不再使用时通过close()方法显式关闭它们。使用try-with-resources是Java中管理这些资源的最佳实践，可以确保资源在块结束时自动关闭，即使发生异常。
异常处理: 网络通信容易出现各种异常，如UnknownHostException、IOException等。应在代码中加入适当的try-catch块来捕获并处理这些异常，提高程序的健壮性。
线程模型: 上述服务器代码是单线程的，一次只能处理一个客户端。在实际应用中，如果需要同时处理多个客户端连接，服务器端通常需要采用多线程模型，即为每个接受的connectionSocket启动一个新的线程来处理其通信。
优雅关机: “stop”指令是一种实现优雅关机的方式。客户端发送此指令，服务器收到后关闭与该客户端的连接。客户端检测到服务器关闭后也退出。这种机制比直接强制终止进程更友好。
协议设计: 在更复杂的应用中，通常会定义更完善的通信协议，例如使用特定的消息头、长度字段或更复杂的命令结构，以确保数据传输的可靠性和灵活性。

总结

通过引入服务器端的内部循环来处理单个客户端的连续请求，并利用BufferedReader.readLine()返回null的特性来检测连接关闭，我们可以有效地实现Java TCP长连接中的多行数据传输和基于特定指令（如“stop”）的连接终止。同时，遵循良好的资源管理和异常处理实践，是构建稳定、可靠网络应用程序的关键。

以上就是Java TCP通信：实现连续数据读取与“停止”机制的详细内容，更多请关注php中文网其它相关文章！