Java TCP通信中实现持续数据读写及优雅终止连接-java教程-PHP中文网

java tcp通信中实现持续数据读写及优雅终止连接

本文详细介绍了在Java TCP客户端-服务器应用中，如何利用BufferedReader实现持续的数据读写，直至接收到特定终止指令（如"stop"）或连接关闭。文章分析了初始代码中一次性读取一行数据的问题，并提供了通过引入内部循环、检测终止指令以及处理连接关闭信号来优化服务器和客户端逻辑的解决方案，确保通信的稳定性和连接的优雅关闭。

1. 初始问题分析

在Java TCP通信中，常见的需求是客户端和服务器之间能够持续交换数据，直到一方发出终止信号。然而，初学者在实现此类功能时，常遇到只能读取一行数据后通信中断的问题。这通常是由于服务器端的循环逻辑不正确导致的。

考虑以下初始的客户端和服务器代码：

客户端 (Klient.java)

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(); // 未执行的关闭操作
    }
}

登录后复制

服务器 (TCPServer.java)

立即学习“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);
            // 连接在处理完一行后未被持续使用，而是等待下一个新连接
        }
    }
}

登录后复制

上述服务器代码的问题在于，while (true)循环的每次迭代都会调用 welcomeSocket.accept() 来接受一个新的客户端连接。这意味着，在处理完一个客户端发送的一行数据并返回响应后，服务器会立即回到循环的开始，并等待新的客户端连接。对于当前的客户端而言，服务器在处理完第一行后就“不再理会”它，导致客户端尝试读取后续响应时可能阻塞或遇到错误，因为它所连接的服务器端逻辑已经转去等待新连接了。

2. 服务器端优化：实现持续通信与优雅终止

为了使服务器能够与单个客户端进行持续通信，我们需要在接受连接后引入一个内部循环来处理该客户端的所有消息，直到该客户端发出终止信号。

2.1 引入内部循环处理单个客户端会话

服务器应该在接受一个连接后，在一个新的内部循环中持续读取来自该客户端的数据，直到收到特定的“停止”指令。

火龙果写作

用火龙果，轻松写作，通过校对、改写、扩展等功能实现高质量内容生产。

106

查看详情

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() + " 已连接。");

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

            // 内部循环：处理当前客户端的所有消息
            while (true) {
                clientSentence = inFromClient.readLine(); // 持续读取客户端发送的行
                if (clientSentence == null) { // 客户端关闭连接时 readLine() 返回 null
                    System.out.println("客户端 " + connectionSocket.getInetAddress() + " 已断开连接。");
                    break; // 退出内部循环，处理下一个客户端
                }

                if (clientSentence.equalsIgnoreCase("stop")) { // 检查终止指令
                    System.out.println("收到客户端 " + connectionSocket.getInetAddress() + " 的终止指令 'stop'。");
                    outToClient.writeBytes("服务器已收到停止指令，连接关闭。\n"); // 可选：发送确认消息
                    connectionSocket.close(); // 关闭当前客户端连接
                    break; // 退出内部循环，等待下一个客户端
                }

                capitalizedSentence = clientSentence.toUpperCase() + '\n';
                outToClient.writeBytes(capitalizedSentence);
                System.out.println("收到: " + clientSentence + ", 发送: " + capitalizedSentence.trim());
            }
        }
        // welcomeSocket.close(); // 如果服务器需要完全终止，则在此处关闭ServerSocket
    }
}

登录后复制

说明：

外层 while(true)： 负责不断监听并接受新的客户端连接。
内层 while(true)： 一旦接受到一个客户端连接，就进入此循环，持续读取来自该客户端的数据。
inFromClient.readLine()： 每次读取客户端发送的一行数据。
clientSentence == null： 当客户端关闭其输出流或连接时，readLine()会返回null，这是服务器检测客户端断开连接的一种方式。
clientSentence.equalsIgnoreCase("stop")： 服务器检测到特定的“stop”指令（不区分大小写）时，会关闭当前 connectionSocket 并退出内部循环，从而结束与该客户端的会话，然后等待新的客户端连接。
资源关闭： 及时关闭 connectionSocket 是非常重要的，以释放系统资源。

2.2 服务器完全终止（处理单个客户端后）

如果服务器的设计是只处理一个客户端会话，然后就完全终止，可以移除外层 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("服务器已启动，等待单个客户端连接...");

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

            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("收到客户端 " + connectionSocket.getInetAddress() + " 的终止指令或连接已断开。");
                    outToClient.writeBytes("服务器已收到停止指令或连接已断开，会话结束。\n");
                    connectionSocket.close();
                    break;
                }
                capitalizedSentence = clientSentence.toUpperCase() + '\n';
                outToClient.writeBytes(capitalizedSentence);
                System.out.println("收到: " + clientSentence + ", 发送: " + capitalizedSentence.trim());
            }
        } finally {
            welcomeSocket.close(); // 确保ServerSocket在所有操作完成后关闭
            System.out.println("服务器已关闭。");
        }
    }
}

登录后复制

3. 客户端优化：检测服务器关闭与优雅退出

客户端也需要相应的修改，以便在服务器关闭连接时能够检测到并优雅地退出循环。BufferedReader.readLine() 方法在流的末尾（即服务器关闭连接）时会返回 null。

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
        try {
            clientSocket = new Socket("127.0.0.1", 6789);
            DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());
            BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

            System.out.println("已连接到服务器。输入消息，输入 'stop' 结束会话。");

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

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

                if (sentence.equalsIgnoreCase("stop")) { // 如果用户输入 "stop"，则客户端也准备退出
                    System.out.println("发送 'stop' 指令，准备关闭连接...");
                    break; // 退出循环
                }

                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 {
            if (clientSocket != null && !clientSocket.isClosed()) {
                clientSocket.close(); // 确保关闭客户端套接字
                System.out.println("客户端连接已关闭。");
            }
        }
    }
}

登录后复制

说明：

modifiedSentence == null： 客户端通过检查 inFromServer.readLine() 的返回值是否为 null 来判断服务器是否已关闭连接。
if (sentence.equalsIgnoreCase("stop"))： 客户端在发送“stop”指令后，也会立即退出自身的发送/接收循环，从而优雅地结束会话。
try-finally 块： 确保无论发生何种异常，clientSocket 都能被正确关闭，释放资源。

4. 总结与注意事项

通过上述优化，我们的Java TCP客户端-服务器应用现在能够实现持续的双向通信，并且能够通过发送特定指令（"stop"）或检测连接关闭来优雅地终止会话。

关键点回顾：

服务器端内部循环： 在接受一个客户端连接后，使用一个内部 while 循环来处理该客户端的所有消息，而不是每次都接受新连接。
终止指令检测： 在服务器端，通过检查接收到的消息是否为“stop”指令来决定何时关闭当前客户端连接。
客户端连接关闭检测： 客户端通过检查 BufferedReader.readLine() 返回 null 来判断服务器是否已关闭连接。
资源管理： 始终确保在通信结束后关闭 Socket 和 ServerSocket 对象，以避免资源泄露。使用 try-with-resources 或 finally 块是推荐的做法。
多线程考虑： 对于能够同时服务多个客户端的服务器，ServerSocket.accept() 应该在一个主线程中运行，而每个接受到的 Socket connectionSocket 都应该在一个单独的线程中处理其内部循环，以避免阻塞其他客户端的连接。上述服务器示例是一个单线程服务器，一次只能处理一个客户端。

遵循这些原则，可以构建出更健壮、更专业的TCP通信应用程序。

以上就是Java TCP通信中实现持续数据读写及优雅终止连接的详细内容，更多请关注php中文网其它相关文章！