【网络】TCP回显服务器和客户端的构造，以及相关bug解决方法 ...

不像 UDP 有 DatagramPacket 是专门的“UDP 数据报”，TCP 没有专门的“TCP 数据报”

• 因为 TCP 是面向字节流的，TCP 传输数据的根本单位就是 byte
  
• UDP 是面向数据报，UDP 这里需要界说专门的类，表示 UDP 数据报，作为 UDP 传输的根本单位
  
• TCP 这里在进行读数据大概写数据的时间，都是以字节或字节数组作为参数进行操纵的
  

ServerSocket

专门给服务器使用的 socket 对象
构造方法

方法签名方法说明ServerSocket(int port) 创建⼀个服务端流套接字 Socket，并绑定到指定端⼝创建⼀个服务端流套接字 Socket，并绑定到指定端⼝ 方法

方法签名方法说明Socket accept()开始监听指定端⼝（创建时绑定的端⼝），有客⼾端连接后，返回⼀个服务端 Socket 对象，并基于该 Socket 建⽴与客⼾端的连接，否则阻塞等候void close()关闭此套接字

• TCP 是有连接的，有连接就需要有一个“创建连接”的过程
  
  
  
  • 创建连接的过程就类似于打电话
    
  • 此处的 accept 就相当于接电话
    
  • 由于客户端是“主动发起”的一方，服务器是“被动继承”的一方，肯定是客户端打电话，服务器接电话
    
  
  

Socket

既会给客户端使用，又会给服务器使用
构造方法

方法签名方法说明Socket(String host, int port)创建⼀个客⼾端流套接字 Socket，并与对应 IP 的主机上，对应端⼝的进程建⽴连接

• 构造这个对象，就是和服务器“打电话”，创建连接
  

方法

方法签名方法说明InetAddress getInetAddress()返回套接字所连接的地址InputStream getInputStream()返回此套接字的输⼊流OutputStream getOutputStream()返回此套接字的输出流 InputStream 和 OutputStream 称为“字节流”

• 前面针对文件操纵的方法，针对此处的 TCP Socket 来说，也是完全适用的
  

回显服务器（Echo Server）

1. 构造方法

• 创建一个 Server Socket 对象，起到“遥控网卡”的作用
  

1. import java.io.IOException;  
2. import java.net.ServerSocket;  
3.   
4. public class TcpEchoServer {  
5.     private ServerSocket serverSocket= null;  
6.   
7.     public TcpEchoServer(int port) throws IOException {  
8.         serverSocket = new ServerSocket(port);  
9.     }
10. }

复制代码

• 对于服务器这一端来说，需要在 socket 对象创建的时间，就指定一个端标语 port，作为构造方法的参数
  
• 后续服务器开始运行之后，操纵系统就会把端标语和该进程关联起来
  
• 端标语的作用就是来区分进程的，一台主机上可能有很多个进程很多个程序，都要去操纵网络。当我们收到数据的时间，哪个进程来处置处罚，就需要通过端标语去区分
  
  
  
  • 所以就需要在程序一启动的时间，就把这个程序关联哪个端口指明清晰
    
  
  

---

• 在调用这个构造方法的过程中，JVM 就会调用系统的 Socket API，完成“端标语-进程”之间的关联动作
  
  
  
  • 如许的操纵也叫“绑定端标语”（系统原生 API 名字就叫 bind）
    
  • 绑定好了端标语之后，就明确了端标语和进程之间的关联关系
    
  
  

---

• 对于一个系统来说，同一时候，一个端标语只能被一个进程绑定；但是一个进程可以绑定多个端标语（通过创建多个 Socket 对象来完成）
  
  
  
  • 因为端标语是用来区分进程，收到数据之后，明确说这个数据要给谁，如果一个端标语对应到多个进程，那么就难以起到区分的结果
    
  • 如果有多个进程，实验绑定一个端标语，只有一个能绑定成功，厥后的都会绑定失败
    
  
  

2. 创建连接

1. public void start() throws IOException {  
2.     while(true) {  
3.         //建立连接  
4.         Socket clientSocket = serverSocket.accept();  
5.         processConnection(clientSocket);  
6.     }
7. }

复制代码

• TCP 创建连接的流程，是操纵系统内核完成的，我们的代码感知不到
  
  
  
  • accept 操纵，是内核已经完成了连接创建的操纵，然后才华够进行“接通电话”
    
  • accept 相当于是针对内核中已经创建好的连接进行“确认”动作
    
  
  
• 由于 accept 的返回对象是 Socket，所以还需要创建一个 clientSocket 来接收返回值
  
  
  
  • clientSocket 和 serverSocket 这两个都是 Socket，都是“网卡的遥控器”，都是用来操纵网卡的。但是在 TCP 中，使用两个差别的 Socket 进行表示，他们的分工是差别的，作用是差别的
    
    
    
    • serverSocket 就相当于是卖房子的贩卖，负责在外面揽客
      
    • clientSocket 相当于是售楼部里面的置业顾问，提供“一对一服务”
      
    
    
  
  

processConnection 方法的创建

针对一个连接，提供处置处罚逻辑

• 先打印客户端信息
  
• 然后创建一个 InputStream 对象用来读取数据，创建一个 OutputStream 对象
  
• 随后，在 while 死循环中完成客户端针对请求的响应处置处罚
  

1. private void processConnection(Socket clientSocket) {  
2.     //打印客户端信息  
3.     System.out.printf("[%s:%d] 客户端上线！\n",clientSocket.getInetAddress(),clientSocket.getPort());  
4.     try(InputStream inputStream = clientSocket.getInputStream();  
5.         OutputStream outputStream = clientSocket.getOutputStream()){  
6.         while(true) {  
7.             // 1. 读取请求并解析  
8.             // 2. 根据请求计算响应  
9.             // 3. 把响应写回给客户端  
10.         }  
11.     }catch (IOException e){  
12.         e.printStackTrace();  
13.     }   
14.     System.out.printf("[%s:%d] 客户端下线！",clientSocket.getInetAddress(),clientSocket.getPort());  
15. }

复制代码

• 因为 TCP 是全双工的通讯，所以一个 Socket 对象，既可以读，也可以写
  
• 因此就可以通过 clientSocket 对象拿出里面的 InputStream 和 OutputStream，我们就既能读，也能写了
  

1. 读取请求并剖析

通过 inputStream.read() 读取请求，但如果直接如许读就不方便，读到的还是二进制数据

• 我们可以先使用 Scanner 包装一下 InputStream，如许就可以更方便地读取这里的请求数据了
  

1. //针对一个连接，提供处理逻辑  
2. private void processConnection(Socket clientSocket) {  
3.     //打印客户端信息  
4.     System.out.printf("[%s:%d] 客户端上线！",clientSocket.getInetAddress(),clientSocket.getPort());  
5.     try(InputStream inputStream = clientSocket.getInputStream();  
6.         OutputStream outputStream = clientSocket.getOutputStream()){  
7.                   Scanner scanner = new Scanner(inputStream);
8.         //使用 Scanner 包装一下 InputStream，就可以更方便地读取这里的请求数据了  
9.         while(true) {  
10.             // 1. 读取请求并解析   
11.             if(!scanner.hasNext()){  
12.                 //如果 scanner 无法读取数据，说明客户端关闭了连接，导致服务器这边读取到 “末尾”  
13.                 break;  
14.             }         
15.             // 2. 根据请求计算响应  
16.             // 3. 把响应写回给客户端  
17.         }  
18.     }catch (IOException e){  
19.         e.printStackTrace();  
20.     }   
21.     System.out.printf("[%s:%d] 客户端下线！",clientSocket.getInetAddress(),clientSocket.getPort());  
22. }

复制代码

• 当 scanner 无法读取出数据时（scanner 没有下一个数据了），说明客户端关闭了连接，导致服务器这边读到了末端，就进行 break
  
  
  
  • 在这个判断的外面（try/catch 外面）加上日志，当数据读完后 break 了，就打印日志
    
  
  

2. 根据请求盘算响应

由于是回显服务器，所以请求就是响应，process 就是直接 return request

1. //针对一个连接，提供处理逻辑  
2. private void processConnection(Socket clientSocket) {  
3.     //打印客户端信息  
4.     System.out.printf("[%s:%d] 客户端上线！",clientSocket.getInetAddress(),clientSocket.getPort());  
5.     try(InputStream inputStream = clientSocket.getInputStream();  
6.         OutputStream outputStream = clientSocket.getOutputStream()){  
7.         Scanner scanner = new Scanner(inputStream);
8.         //使用 Scanner 包装一下 InputStream，就可以更方便地读取这里的请求数据了  
9.         while(true) {  
10.             // 1. 读取请求并解析   
11.             if(!scanner.hasNext()){  
12.                 //如果 scanner 无法读取数据，说明客户端关闭了连接，导致服务器这边读取到 “末尾”  
13.                 break;  
14.             }         
15.             // 2. 根据请求计算响应  
16.             String response = process(request);
17.             // 3. 把响应写回给客户端  
18.         }  
19.     }catch (IOException e){  
20.         e.printStackTrace();  
21.     }   
22.     System.out.printf("[%s:%d] 客户端下线！",clientSocket.getInetAddress(),clientSocket.getPort());  
24.         private String process(String request) {  
25.             return request;  
26.         }
27. }

复制代码

• 这里的请求就是读取的 InputStream 里面的数据
  

3. 把响应写回给客户端

1. //针对一个连接，提供处理逻辑  
2. private void processConnection(Socket clientSocket) {  
3.     //打印客户端信息  
4.     System.out.printf("[%s:%d] 客户端上线！",clientSocket.getInetAddress(),clientSocket.getPort());  
5.     try(InputStream inputStream = clientSocket.getInputStream();  
6.         OutputStream outputStream = clientSocket.getOutputStream()){  
7.         Scanner scanner = new Scanner(inputStream);  
8.         //使用 Scanner 包装一下 InputStream，就可以更方便地读取这里的请求数据了  
9.         PrintWrite printWriter = new PrintWriter(outputStream);
10.         
11.         while(true) {  
12.             // 1. 读取请求并解析  
13.             Scanner scanner = new Scanner(inputStream);  
14.             if(!scanner.hasNext()){  
15.                 //如果 scanner 无法读取数据，说明客户端关闭了连接，导致服务器这边读取到 “末尾”  
16.                 break;  
17.             }         
18.             // 2. 根据请求计算响应  
19.             String response = process(request);
20.             // 3. 把响应写回给客户端  
21.             printWriter.println(response);
22.         }  
23.     }catch (IOException e){  
24.         e.printStackTrace();  
25.     }   
26.     System.out.printf("[%s:%d] 客户端下线！",clientSocket.getInetAddress(),clientSocket.getPort());  
28.         private String process(String request) {  
29.             return request;  
30.         }
31. }

复制代码

• 此处写入响应的时间，会在末端加上“\n”
  
  
  
  • 我们在刚才在使用 scanner 读取请求的时间，隐蔽了一个条件——请求是以“空白符”（空格、回车、制表符、垂直制表符、翻页符…）末端，否则就会在 next() 大概 hasNext() 那里发生阻塞，如许就没法读取到数据了
    
  • 因此此处约定，使用“\n”作为请求和响应的末端标志
    
  
  
• TCP 是字节流的，读写方式存在无数种可能，就需要有办法区分出，从那里到那里是一个完整的请求
  
  
  
  • 此处就可以引入分隔符来区分
    
  
  

3. 完整代码

1. import java.io.IOException;  
2. import java.io.InputStream;  
3. import java.io.OutputStream;  
4. import java.io.PrintWriter;  
5. import java.net.ServerSocket;  
6. import java.net.Socket;  
7. import java.util.Scanner;  
8.   
9. public class TcpEchoServer {  
10.     private ServerSocket serverSocket= null;  
11.   
12.     public TcpEchoServer(int port) throws IOException {  
13.         serverSocket = new ServerSocket(port);  
14.     }  
15.    
16.     public void start() throws IOException {  
17.         while(true) {  
18.             //建立连接  
19.             Socket clientSocket = serverSocket.accept();  
20.             processConnection(clientSocket);  
21.         }   
22.     }  
23.     //针对一个连接，提供处理逻辑  
24.     private void processConnection(Socket clientSocket) {  
25.         //打印客户端信息  
26.         System.out.printf("[%s:%d] 客户端上线！",clientSocket.getInetAddress(),clientSocket.getPort());  
27.         try(InputStream inputStream = clientSocket.getInputStream();  
28.             OutputStream outputStream = clientSocket.getOutputStream()){  
29.             Scanner scanner = new Scanner(inputStream);  
30.             PrintWriter printWriter = new PrintWriter(outputStream);  
31.             //使用 Scanner 包装一下 InputStream，就可以更方便地读取这里的请求数据了  
32.             while(true) {  
33.                 // 1. 读取请求并解析  
34.                 if(!scanner.hasNext()){  
35.                     //如果 scanner 无法读取数据，说明客户端关闭了连接，导致服务器这边读取到 “末尾”  
36.                     break;  
37.                 }               
38.                 String request = scanner.next();  
39.                 // 2. 根据请求计算响应  
40.                 String response = process(request);  
41.                 // 3. 把响应写回给客户端  
42.                 printWriter.println(response);  
43.   
44.                 System.out.printf("[%s:%d] req=%s; resp=%s\n", clientSocket.getInetAddress(),clientSocket.getPort());  
45.   
46.             }        
47.         }catch (IOException e){  
48.             e.printStackTrace();  
49.         }        
50.         System.out.printf("[%s:%d] 客户端下线！",clientSocket.getInetAddress(),clientSocket.getPort());  
51.     }  
52.     private String process(String request) {  
53.         return request;  
54.     }  
55.    
56.     public static void main(String[] args) throws IOException {  
57.         TcpEchoServer server = new TcpEchoServer(9090);  
58.         server.start();  
59.     }
60. }

复制代码

虽然把服务器代码编写的差不多了，但还存在三个非常严重的标题，都会导致严重的 bug
但需要联合后面客户端的代码进行分析
客户端（Echo Client）

1. 构造方法

起首创建一个 Socket 对象，来进行网络通讯，再创建构造方法

1. import java.io.IOException;  
2. import java.net.Socket;  
3.   
4. public class TcpEchoClient {  
5.     private Socket socket = null;  
6.   
7.     public TcpEchoClient(String serverIp, int serverPort) throws IOException {  
8.         socket = new Socket(serverIp,serverPort);  
9.     }
10. }

复制代码

• 写构造方法的时间，就不能使用无参数的版本了，需要在这里指定要访问的服务器的 IP 和端标语
  
  
  
  • 这里可以直接填入一个 String 类型的 IP，不消像前面 UDP 那样还需要手动转换
    
  
  

2. 启动客户端

• 先拿出 socket 里面的 InputStream 和 OutputStream，再进行 while 循环
  
• 使用 Scanner 包装一下 InputStream，如许就可以更方便地读取这里的请求数据了
  
• 实例化一个 PrintWriter 对象，获取到 OutputStream，方便后续对数据进行打印
  
• 创建一个 scannerIn 对象，用来读取从控制台输入的数据
  

1. public void start() {  
2.     System.out.println("客户端启动！");  
3.     try(InputStream inputStream = socket.getInputStream();  
4.         OutputStream outputStream = socket.getOutputStream()) {  
5.         
6.         Scanner scanner = new Scanner(inputStream);  
7.         Scanner scannerIn = new Scanner(System.in);  
8.         PrintWriter printWriter = new PrintWriter(outputStream);  
9.   
10.         while(true){  
11.             //1. 从控制台读取数据  
12.             System.out.println("-> ");  
13.             String request = scannerIn.next();  
14.             //2. 把请求发送给服务器  
15.             printWriter.println(request);  
16.             //3. 从服务器读取响应  
17.             if(!scanner.hasNext()){  
18.                 break;  
19.             }            
20.             String response = scanner.next();  
21.             //4. 打印响应结果  
22.             System.out.println(response);  
23.         }   
24.     } catch (Exception e) {  
25.         throw new RuntimeException(e);  
26.     }
27. }

复制代码

• 步骤上和 UDP 是非常相似的，只不外此处的 API 不一样
  
• 前面的 UDP 不管发送也好，接收也罢，都是先去构造一个 DatagramPacket 再去操纵，但是对于 TCP 来说，它是纯字节流的操纵，就拿字节作为单位进行操纵即可
  
  
  
  • 这里为了操纵方便，又给这个字节流套上了对应的字符流/工作类，之后再去进行读写，都会非常方便
    
  
  

3. 完整代码

1. import java.io.IOException;  
2. import java.io.InputStream;  
3. import java.io.OutputStream;  
4. import java.io.PrintWriter;  
5. import java.net.Socket;  
6. import java.util.Scanner;  
7.   
8. public class TcpEchoClient {  
9.     private Socket socket = null;  
10.   
11.     public TcpEchoClient(String serverIp, int serverPort) throws IOException {  
12.         socket = new Socket(serverIp,serverPort);  
13.     }  
14.    
15.     public void start() {  
16.         System.out.println("客户端启动！");  
17.         try(InputStream inputStream = socket.getInputStream();  
18.             OutputStream outputStream = socket.getOutputStream()) {  
19.             Scanner scanner = new Scanner(inputStream);  
20.             Scanner scannerIn = new Scanner(System.in);  
21.             PrintWriter printWriter = new PrintWriter(outputStream);  
22.   
23.             while(true){  
24.                 //1. 从控制台读取数据  
25.                 System.out.println("-> ");  
26.                 String request = scannerIn.next();  
27.                 //2. 把请求发送给服务器  
28.                 printWriter.println(request);  
29.                 //3. 从服务器读取响应  
30.                 if(!scanner.hasNext()){  
31.                     break;  
32.                 }               
33.                 String response = scanner.next();  
34.                 //4. 打印响应结果  
35.                 System.out.println(response);  
36.             }        
37.         } catch (Exception e) {  
38.             throw new RuntimeException(e);  
39.         }   
40.     }  
41.    
42.     public static void main(String[] args) throws IOException {  
43.         TcpEchoClient client = new TcpEchoClient("127.0.0.1",9090);  
44.         client.start();  
45.     }
46. }

复制代码

服务器代码中的三个严重 bug

1. 内存缓冲区

• 客户端发送了数据之后，并没有任何响应
  此处的环境是，客户端并没有真正的将数据发送出去，服务器没有收到，自然没有任何响应
  

1. //这是客户端中，将数据发送给服务器的代码  
2. printWriter.println(request);
4. //这是服务器中，把响应写回给客户端的代码
5. printWriter.println(response);  

复制代码

• PrintWriter 如许的类，以及很多 IO 流中的类，都是“自带缓冲区”的
  
  
  
  • 进行文件/网络操纵，都是 IO 操纵，IO 操纵本身是一种耗时比力多，开销比力大的操纵。耗时比力多的操纵频仍进行，就会影响程序实行服从，所以我们可以引入“缓冲区”，减少 IO 的次数，从而进步服从
    
  • 引入“缓冲区”之后，进行写入操纵，不会立即触发 IO，而是先放到内存缓冲区中，等到缓冲区里攒了一波之后，再统一进行发送
    
  
  

---

• 此处可以引入 flush 操纵，主动“刷新缓冲区”
  
  
  
  • flush 的原意为“冲刷”，类似于冲厕所
    
  
  

---

改为：

1. // 客户端  
2. printWriter.println(request);
3. printWriter.flush();
5. // 服务器
6. printWriter.println(response);
7. printWriter.flush();

复制代码

2. 资源释放

• 当前的服务器代码，针对 clientSocket 没有进行 close 操纵
  

1. while(true) {  
2.     //建立连接  
3.     Socket clientSocket = serverSocket.accept();  
4.     processConnection(clientSocket);  
5. }

复制代码

• 像 ServerSocket 和 DatagramPacket，它们的生命周期都是跟随整个进程的，和进程同存亡，进程关了之后他俩对应的资源也释放了
  
• 但此处的 clientSocket 并非云云，它是“连接级别”的数据，随着客户端断开连接了，这个 Socket 也就不再使用了，但资源是不释放的
  
  
  
  • 即使是同一个客户端，断开之后，重新连接，也是一个新 Socket，和旧的 Socket 不是同一个了
    
  • 因此，如许的 Socket 就应该主动关闭掉，避免文件资源泄漏
    
  
  

---

改后：
把 close 加到 finally 里面，把日志前移（不然释放之后日志就打印不出来了）

1. private void processConnection(Socket clientSocket) throws IOException {  
2.    
3.     try(InputStream inputStream = clientSocket.getInputStream();  
4.         OutputStream outputStream = clientSocket.getOutputStream()){  
5.         ...
6.         while(true) {  
7.             ...
8.         }   
9.     }catch (IOException e){  
10.         e.printStackTrace();  
11.     }finally {  
12.         System.out.printf("[%s:%d] 客户端下线！\n",clientSocket.getInetAddress(),clientSocket.getPort());  
13.         clientSocket.close();  
14.     }
15. }

复制代码

GC 释放的是内存资源，此处讨论的“文件资源泄漏”是针对文件形貌符的

• 其实，流对象如果被 GC 回收了，也是会自动实行 close 的，但是由于 GC 过程是不可逆的（不知道 GC 什么时间发生，也不知到这次 GC 是否能释放掉你这个对象）
  
• 一个对象可能不会很及时释放，在有些环境下，在还没来得及释放的时间，就导致这里的文件形貌符就没了
  
• 因此，我们写代码不能全指望这个东西，尤其是当前“高并发”服务器的背景下，短时间内就可能处置处罚大量的客户端
  

3. 多个客户端连接同一个服务器

• 实验使用多个客户端来同时连接服务器
  作为一个服务器，就是要同时给多个客户端提供服务的
  

• 当第一个客户端连上服务器之后，服务器代码救护已进入 processConnect 内部的 while 循环，无法跳出
  
• 此时第二个客户端实验连接的时间，无法实行到第二次 accept
  
• 所有第二个客户端发来的请求数据，都积压在操纵系统的内核的接收缓冲区中
  第一个客户端推出的时间，processConnect 的循环就竣事了，于是外层的循环就可以实行 accept 了，也是就可以处置处罚第二个客户端之前积压的请求数据了
  
• 此处无法处置处罚多个客户端，本质上是服务器代码布局存在标题
  
• 接纳了双重 while 循环的写法，导致进入里层 while 的时间，外层 while 就无法实行了
  
• 解决办法就是：把双重 while 改成一重 while，分别进行实行——使用多线程
  

改后：

1. public void start() throws IOException {  
2.     while(true) {  
3.         //建立连接  
4.         Socket clientSocket = serverSocket.accept();  
5.         Thread t = new Thread(() -> {  
6.             try {  
7.                 processConnection(clientSocket);  
8.             } catch (IOException e) {  
9.                 throw new RuntimeException(e);  
10.             }        
11.         });        
12.         t.start();  
13.     }
14. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。