• 《bug记录》在利用TCP协议创建【服务器-客户端交互程序】中出现的一些问题

    目录

    一、bug描述

     二、问题分析

    三、问题解决

    🍑改过后的服务器代码

     🍑改过后的客户端代码：

    四、进一步的改进

    一、bug描述

     

    今天在写上传交互程序中，当我把服务器和客户端成功启动后，在客户端输入请求指令的时候，出现了上述情况。

    下面是服务器的代码

    1. package network;
    2.  
    3. import java.io.*;
    4. import java.net.ServerSocket;
    5. import java.net.Socket;
    6. import java.util.Scanner;
    7.  
    8. public class TcpEchoServer {
    9.     ServerSocket serverSocket = null;
    10.     public TcpEchoServer(int port) throws IOException {
    11.         serverSocket = new ServerSocket(port);
    12.     }
    13.     public void start() throws IOException {
    14.         // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
    15.         Socket clientSocket = serverSocket.accept();
    16.         processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务
    17.     }
    18.     // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    19.     public void processConnection(Socket clientSocket) throws IOException {
    20.         System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
    21.         try (InputStream inputStream = clientSocket.getInputStream();
    22.              OutputStream outputStream = clientSocket.getOutputStream() ) {
    23.             Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
    24.             PrintWriter printWriter = new PrintWriter(outputStream);
    25.             while (true) {
    26.                 if (!scannerNet.hasNext()) {
    27.                     // 说明此时连接中断，服务器无法继续从客户端读取到请求
    28.                     // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 false
    29.                     System.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
    30.                     break;
    31.                 }
    32.                 // 1、读取客户端的请求
    33.                 String request = scannerNet.nextLine();
    34.                 // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
    35.                 // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
    36.                 // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
    37.                 // 2、处理客户端发来的请求
    38.                 String response = process(request);
    39.                 // 3、把响应发送给客户端
    40.                 printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
    41.                 printWriter.flush(); // 刷新缓冲区
    42.                 // 打印日志
    43.                 System.out.printf("request: %s, response: %s\n", request, response);
    44.             }
    45.         }
    46.         finally {
    47.             clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
    48.         }
    49.  
    50.     }
    51.     public String process(String request) {
    52.         return request;
    53.     }
    54.  
    55.     public static void main(String[] args) throws IOException {
    56.         TcpEchoServer server = new TcpEchoServer(8000);
    57.         server.start();
    58.     }
    59. }

    客户端的代码：

    1. package network;
    2.  
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.io.OutputStream;
    6. import java.io.PrintWriter;
    7. import java.net.Socket;
    8. import java.util.Scanner;
    9.  
    10. public class TcpEchoClient {
    11.     Socket socket = null;
    12.  
    13.     public TcpEchoClient() throws IOException {
    14.         // 指定客户端要连接的服务器
    15.         socket = new Socket("127.0.0.1", 8000);
    16.         // 程序走到了这里，说明客户端和服务器就已经成功建立了连接
    17.     }
    18.  
    19.     public void start() throws IOException {
    20.         Scanner scanner = new Scanner(System.in);
    21.         System.out.println("当前是客户端，请输入请求");
    22.  
    23.         try (InputStream inputStream = socket.getInputStream();
    24.              OutputStream outputStream = socket.getOutputStream()) { // InputStream用于读取， OutputStream用于发送
    25.             // 对我们的读取和发送进行写包装，使得读取和包装更方便
    26.             Scanner scannerNet = new Scanner(inputStream);
    27.             PrintWriter printWriter = new PrintWriter(outputStream);
    28.             // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    29.             while (true) {
    30.                 System.out.print("> ");
    31.                 // 1、客户端从键盘输入请求
    32.                 String request = scanner.nextLine();
    33.                 // 在这里我们虽然在输入内容后用换行符来进行了结束，但我们用于接收的request并没有读取的换行符——它被nextLine()给吞吃了
    34.                 // 2、把请求发送给服务器
    35.  
    36.                 printWriter.write(request);
    37.                 // 这么写会产生一个bug, 要printWriter.println()会自动给我们要写入的添加一个换行符
    38.                 // 可以让服务器在读取请求时遇到换行就结束，不至于陷入阻塞
    39.                 printWriter.flush(); // 刷新缓冲区
    40.                 // 3、从服务器读取响应内容
    41.                 String response = scannerNet.nextLine();
    42.                 // 4、打印日志
    43.                 System.out.printf("request: %s, response: %s\n", request, response);
    44.             }
    45.         }
    46.         finally {
    47.             socket.close();
    48.         }
    49. }
    50.     public static void main(String[] args) throws IOException {
    51.         TcpEchoClient client = new TcpEchoClient();
    52.         client.start();
    53.     }
    54. }

     

     二、问题分析

    于是我打开java的工具包jconsole.exe查看相关的线程执行情况 

     ​​​​​​​

     

    客户端相关代码： 

     

     

    那么客户端在这里出现异常正常吗？很正常因为我们的服务器在正常情况下，当把响应发送给客户端后，是要打印日志的。但从我们上述的运行结果来看，我们的服务器并没有打印响应（这说明服务器没有成功的把响应发送给客户端，而是陷入了阻塞）

    所以客户端在这里的阻塞是正常的

     对应的服务器代码：

     

     

    那么我们在来看看服务器的代码究竟在哪里出现了问题：’

     

     对应的服务器代码： 

    为什么会在scannerNet.nextLine()这里陷入阻塞呢？nextLine不是遇到回车就结束吗？我们在客户端输入请求后明明敲了一个回车呀！

     

     通过下面这个栗子我们可以发现一些问题：

     

    那么如果这样的话， 我们服务器从客户端读取request的时候，接收到的数据也是没有换行符的——也就是说：

    String request = scannerNet.nextLine();

     这一行的读取一直无法正常的结束，线程自然就陷入了阻塞当中。

     

    三、问题解决

    清楚了这一点就好办了，我们在下面的客户端代码中： 

     

     对应的服务器代码：

    🍑改过后的服务器代码

    1. package network;
    2.  
    3. import java.io.*;
    4. import java.net.ServerSocket;
    5. import java.net.Socket;
    6. import java.util.Scanner;
    7.  
    8. public class TcpEchoServer {
    9.     ServerSocket serverSocket = null;
    10.     public TcpEchoServer(int port) throws IOException {
    11.         serverSocket = new ServerSocket(port);
    12.     }
    13.     public void start() throws IOException {
    14.         // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
    15.         Socket clientSocket = serverSocket.accept();
    16.         processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务
    17.     }
    18.     // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    19.     public void processConnection(Socket clientSocket) throws IOException {
    20.         System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
    21.         try (InputStream inputStream = clientSocket.getInputStream();
    22.              OutputStream outputStream = clientSocket.getOutputStream() ) {
    23.             Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
    24.             PrintWriter printWriter = new PrintWriter(outputStream);
    25.             while (true) {
    26.                 if (!scannerNet.hasNext()) {
    27.                     // 说明此时连接中断，服务器无法继续从客户端读取到请求
    28.                     // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 false
    29.                     System.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
    30.                     break;
    31.                 }
    32.                 // 1、读取客户端的请求
    33.                 String request = scannerNet.nextLine();
    34.                 // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
    35.                 // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
    36.                 // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
    37.                 // 2、处理客户端发来的请求
    38.                 String response = process(request);
    39.                 // 3、把响应发送给客户端
    40.                 printWriter.println(response);
    41.                 // printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
    42.                 printWriter.flush(); // 刷新缓冲区
    43.                 // 打印日志
    44.                 System.out.printf("request: %s, response: %s\n", request, response);
    45.             }
    46.         }
    47.         finally {
    48.             clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
    49.         }
    50.  
    51.     }
    52.     public String process(String request) {
    53.         return request;
    54.     }
    55.  
    56.     public static void main(String[] args) throws IOException {
    57.         TcpEchoServer server = new TcpEchoServer(8000);
    58.         server.start();
    59.     }
    60. }

     

     🍑改过后的客户端代码：

    1. package network;
    2.  
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.io.OutputStream;
    6. import java.io.PrintWriter;
    7. import java.net.Socket;
    8. import java.util.Scanner;
    9.  
    10. public class TcpEchoClient {
    11.     Socket socket = null;
    12.  
    13.     public TcpEchoClient() throws IOException {
    14.         // 指定客户端要连接的服务器
    15.         socket = new Socket("127.0.0.1", 8000);
    16.         // 程序走到了这里，说明客户端和服务器就已经成功建立了连接
    17.     }
    18.  
    19.     public void start() throws IOException {
    20.         Scanner scanner = new Scanner(System.in);
    21.         System.out.println("当前是客户端，请输入请求");
    22.  
    23.         try (InputStream inputStream = socket.getInputStream();
    24.              OutputStream outputStream = socket.getOutputStream()) { // InputStream用于读取， OutputStream用于发送
    25.             // 对我们的读取和发送进行写包装，使得读取和包装更方便
    26.             Scanner scannerNet = new Scanner(inputStream);
    27.             PrintWriter printWriter = new PrintWriter(outputStream);
    28.             // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    29.             while (true) {
    30.                 System.out.print("> ");
    31.                 // 1、客户端从键盘输入请求
    32.                 String request = scanner.nextLine();
    33.                 // 在这里我们虽然在输入内容后用换行符来进行了结束，但我们用于接收的request并没有读取的换行符——它被nextLine()给吞吃了
    34.                 // 2、把请求发送给服务器
    35.  
    36.                 printWriter.println(request);
    37.                 // printWriter.write(request);
    38.                 // 这么写会产生一个bug, 要printWriter.println()会自动给我们要写入的添加一个换行符
    39.                 // 可以让服务器在读取请求时遇到换行就结束，不至于陷入阻塞
    40.                 printWriter.flush(); // 刷新缓冲区
    41.                 // 3、从服务器读取响应内容
    42.                 String response = scannerNet.nextLine();
    43.                 // 4、打印日志
    44.                 System.out.printf("request: %s, response: %s\n", request, response);
    45.             }
    46.         }
    47.         finally {
    48.             socket.close();
    49.         }
    50. }
    51.     public static void main(String[] args) throws IOException {
    52.         TcpEchoClient client = new TcpEchoClient();
    53.         client.start();
    54.     }
    55. }

     

    测试案例

    四、进一步的改进

     实现多线程服务器

    1. package network;
    2.  
    3. import java.io.*;
    4. import java.net.ServerSocket;
    5. import java.net.Socket;
    6. import java.util.Scanner;
    7.  
    8. public class TcpEchoServer {
    9.     ServerSocket serverSocket = null;
    10.     public TcpEchoServer(int port) throws IOException {
    11.         serverSocket = new ServerSocket(port);
    12.     }
    13.     public void start() throws IOException {
    14.         while (true) {
    15.             // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket
    16.             // 如果当前没有客户端来建立连接, 就会阻塞等待!!
    17.             Socket clientSocket = serverSocket.accept();
    18.             // processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务
    19.             // [版本2] 多线程版本. 主线程负责拉客, 新线程负责通信
    20.             // 虽然比版本1 有提升了, 但是涉及到频繁创建销毁线程, 在高并发的情况下, 负担比较重的.
    21.             Thread thread = new Thread(() -> {
    22.                 try {
    23.                     processConnection(clientSocket);
    24.                 } catch (IOException e) {
    25.                     e.printStackTrace();
    26.                 }
    27.             });
    28.             thread.start();
    29.         }
    30.  
    31.     }
    32.     // 通过这个方法, 给当前连上的这个客户端, 提供服务!!
    33.     // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    34.     public void processConnection(Socket clientSocket) throws IOException {
    35.         System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
    36.         try (InputStream inputStream = clientSocket.getInputStream();
    37.              OutputStream outputStream = clientSocket.getOutputStream() ) {
    38.             Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
    39.             PrintWriter printWriter = new PrintWriter(outputStream);
    40.             while (true) {
    41.                 if (!scannerNet.hasNext()) {
    42.                     // 说明此时连接中断，服务器无法继续从客户端读取到请求
    43.                     // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 falseSystem.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
    44.                     break;
    45.                 }
    46.                 // 1、读取客户端的请求
    47.                 String request = scannerNet.nextLine();
    48.                 // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
    49.                 // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
    50.                 // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
    51.                 // 2、处理客户端发来的请求
    52.                 String response = process(request);
    53.                 // 3、把响应发送给客户端
    54.                 printWriter.println(response);
    55.                 // printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
    56.                 printWriter.flush(); // 刷新缓冲区
    57.                 // 打印日志
    58.                 System.out.printf("[%s:%d]  request: %s, response: %s\n",
    59.                         clientSocket.getInetAddress(), clientSocket.getPort(),
    60.                         request, response);
    61.             }
    62.         }
    63.         finally {
    64.             clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
    65.         }
    66.  
    67.     }
    68.     public String process(String request) {
    69.         return request;
    70.     }
    71.  
    72.     public static void main(String[] args) throws IOException {
    73.         TcpEchoServer server = new TcpEchoServer(8000);
    74.         server.start();
    75.     }
    76. }

     

     

    通过线程池实现多线程服务器

    1. package network;
    2.  
    3. import java.io.*;
    4. import java.net.ServerSocket;
    5. import java.net.Socket;
    6. import java.util.Scanner;
    7. import java.util.concurrent.Executor;
    8. import java.util.concurrent.ExecutorService;
    9. import java.util.concurrent.Executors;
    10.  
    11. public class TcpEchoServer {
    12.     ServerSocket serverSocket = null;
    13.     public TcpEchoServer(int port) throws IOException {
    14.         serverSocket = new ServerSocket(port);
    15.     }
    16.     public void start() throws IOException {
    17.         ExecutorService service = Executors.newCachedThreadPool();// 此处不太适合使用 "固定个数的"
    18.         while (true) {
    19.             // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket
    20.             // 如果当前没有客户端来建立连接, 就会阻塞等待!!
    21.             Socket clientSocket = serverSocket.accept();
    22.             // processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务
    23.  
    24.             // [版本2] 多线程版本. 主线程负责拉客, 新线程负责通信
    25.             // 虽然比版本1 有提升了, 但是涉及到频繁创建销毁线程, 在高并发的情况下, 负担比较重的.
    26. //            Thread thread = new Thread(() -> {
    27. //                try {
    28. //                    processConnection(clientSocket);
    29. //                } catch (IOException e) {
    30. //                    e.printStackTrace();
    31. //                }
    32. //            });
    33. //            thread.start();
    34.  
    35.             // [版本3] 使用线程池, 来解决频繁创建销毁线程的问题.
    36.             // 此处不太适合使用 "固定个数的"
    37.             service.submit(new Runnable() {
    38.                 @Override
    39.                 public void run() {
    40.                     try {
    41.                         processConnection(clientSocket);
    42.                     } catch (IOException e) {
    43.                         e.printStackTrace();
    44.                     }
    45.                 }
    46.             });
    47.  
    48.         }
    49.  
    50.     }
    51.     // 通过这个方法, 给当前连上的这个客户端, 提供服务!!
    52.     // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    53.     public void processConnection(Socket clientSocket) throws IOException {
    54.         System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
    55.         try (InputStream inputStream = clientSocket.getInputStream();
    56.              OutputStream outputStream = clientSocket.getOutputStream() ) {
    57.             Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
    58.             PrintWriter printWriter = new PrintWriter(outputStream);
    59.             while (true) {
    60.                 if (!scannerNet.hasNext()) {
    61.                     // 说明此时连接中断，服务器无法继续从客户端读取到请求
    62.                     // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 false
    63.                     System.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
    64.                     break;
    65.                 }
    66.                 // 1、读取客户端的请求
    67.                 String request = scannerNet.nextLine();
    68.                 // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
    69.                 // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
    70.                 // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
    71.                 // 2、处理客户端发来的请求
    72.                 String response = process(request);
    73.                 // 3、把响应发送给客户端
    74.                 printWriter.println(response);
    75.                 // printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
    76.                 printWriter.flush(); // 刷新缓冲区
    77.                 // 打印日志
    78.                 System.out.printf("[%s:%d]  request: %s, response: %s\n",
    79.                         clientSocket.getInetAddress(), clientSocket.getPort(),
    80.                         request, response);
    81.             }
    82.         }
    83.         finally {
    84.             clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
    85.         }
    86.  
    87.     }
    88.     public String process(String request) {
    89.         return request;
    90.     }
    91.  
    92.     public static void main(String[] args) throws IOException {
    93.         TcpEchoServer server = new TcpEchoServer(8000);
    94.         server.start();
    95.     }
    96. }

     

  • 相关阅读:
    基础算法篇——前缀和与差分
    金仓数据库KingbaseES数据库开发指南（6. 业务系统开发建议）
    Postgresql-xl全局快照与GTM代码走读（支线）
    Bert基础(十七)--Bert实战：中文情感识别
    每天五分钟机器学习：支持向量机和逻辑回归损失函数的区别和联系
    Maven 项目配置使用备忘录
    nodejs midway+typeorm搭建后台方案
    18 软专
    Spring之AOP源码解析(中)
    【附源码】计算机毕业设计JAVA在线图书超市
  • 原文地址：https://blog.csdn.net/weixin_61061381/article/details/126193709