• Java EE初阶---网络编程套接字

    1、网络编程基础

    1.1 为什么需要网络编程？

            ——丰富的网络资源
            用户在浏览器中，打开在线视频网站，如优酷看视频，实质是通过网络，获取到网络上的一个视频资源。与本地打开视频文件类似，只是视频文件这个资源的来源是网络。相比本地资源来说，网络提供了更为丰富的网络资源。所谓的网络资源，其实就是在网络中可以获取的各种数据资源而所有的网络资源，都是通过网络编程来进行数据传输的。

    1.2 什么是网络编程

            网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）。

            当然，我们只要满足进程不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据，也属于网络编程。特殊的，对于开发来说，在条件有限的情况下，一般也都是在一个主机中运行多个进程来完成网络编程。但是，我们一定要明确，我们的目的是提供网络上不同主机，基于网络来传输数据资源：

    • 进程A：编程来获取网络资源
    • 进程B：编程来提供网络资源

    1.3 网络编程中的基本概念

    • 发送端和接收端
    在一次网络数据传输时：
    发送端 ：数据的 发送方进程 ，称为发送端。发送端主机即网络通信中的源主机。
    接收端 ：数据的 接收方进程 ，称为接收端。接收端主机即网络通信中的目的主机。
    收发端 ：发送端和接收端两端，也简称为收发端。
    注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念。

    • 请求和响应
    一般来说，获取一个网络资源，涉及到两次网络数据传输：

    第一次：请求数据的发送

    第二次：响应数据的发送。

            好比在快餐店点一份炒饭：先要发起请求：点一份炒饭，再有快餐店提供的对应响应：提供一份炒饭

    • 客户端和服务端
    服务端 ：在常见的网络数据传输场景下，把 提供服务 的一方进程，称为服务端，可以提供对外服务。
    客户端 ： 获取服务 的一方进程，称为客户端。
    对于服务来说，一般是提供：
            客户端获取服务资源

             客户端保存资源在服务端

    好比在银行办事：银行提供存款服务：用户（客户端）保存资源（现金）在银行（服务端）。银行提供取款服务：用户（客户端）获取服务端资源（银行替用户保管的现金）

    1.4 常见的客户端服务端模型

            最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序：
    1. 客户端先发送请求到服务端
    2. 服务端根据请求数据，执行相应的业务处理
    3. 服务端返回响应：发送业务处理结果
    4. 客户端根据响应数据，展示处理结果（展示获取的资源，或提示保存资源的处理结果）

    2、Socket套接字

    2.1 概念

            Socket套接字，是由系统提供用于网络通信的技术，是基于 TCP/IP 协议的网络通信的基本操作单元。基于Socket 套接字的网络程序开发就是网络编程。

    2.2 分类

            Socket套接字主要针对传输层协议划分为如下三类：
    • 流套接字：使用传输层TCP协议
    TCP ，即 Transmission Control Protocol （传输控制协议），传输层协议。以下为TCP 的特点：
    有连接
    可靠传输
    面向字节流
    有接收缓冲区，也有发送缓冲区
    大小不限
            对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收。
    • 数据报套接字：使用传输层UDP协议
    UDP，即User Datagram Protocol（用户数据报协议），传输层协议。以下为UDP的特点：
    无连接
    不可靠传输
    面向数据报
    有接收缓冲区，无发送缓冲区
    大小受限：一次最多传输64k
            对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100 个字节，必须一次发送，接收也必须一次接收100 个字节，而不能分 100 次，每次接收 1 个字节。
    • 原始套接字
    原始套接字用于自定义传输层协议，用于读写内核没有处理的 IP 协议数据。

    2.3 Java数据报套接字通信模型

            对于UDP 协议来说，具有无连接，面向数据报的特征，即每次都是没有建立连接，并且一次发送全部数据报，一次接收全部的数据报。java中使用 UDP 协议通信，主要基于 DatagramSocket 类来创建数据报套接字，并使用DatagramPacket 作为发送或接收的 UDP 数据报。对于一次发送及接收 UDP 数据报的流程如下：

            以上只是一次发送端的UDP数据报发送，及接收端的数据报接收，并没有返回的数据。也就是只有请求，没有响应。对于一个服务端来说，重要的是提供多个客户端的请求处理及响应，流程如下：

    2.4 Java流套接字通信模型

     2.5 Socket编程注意事项

    1. 客户端和服务端：开发时，经常是基于一个主机开启两个进程作为客户端和服务端，但真实的场 景，一般都是不同主机。

    2. 注意目的IP和目的端口号，标识了一次数据传输时要发送数据的终点主机和进程

    3. Socket编程我们是使用流套接字和数据报套接字，基于传输层的TCP或UDP协议，但应用层议，也需要考虑，这块我们在后续来说明如何设计应用层协议。

    4. 关于端口被占用的问题：如果一个进程A已经绑定了一个端口，再启动一个进程B绑定该端口，就会报错，这种情况也叫端口被占用。对于java进程来说，端口被占用的常见报错信息如下：

            此时需要检查进程B绑定的是哪个端口，再查看该端口被哪个进程占用。以下为通过端口号查进程 的方式：

    • 在cmd输入 netstat -ano | findstr 端口号 ，则可以显示对应进程的pid。如以下命令显示了8888进程的pid

    •  在任务管理器中，通过pid查找进程

    解决端口被占用的问题：如果占用端口的进程A不需要运行，就可以关闭A后，再启动需要绑定该端口的进程B。如果需要运行A进程，则可以修改进程B的绑定端口，换为其他没有使用的端口。

    3、UDP数据报套接字编程

    3.1 DatagramSocket API

    DatagramSocket 是 UDP Socket ，用于发送和接收 UDP 数据报。
    DatagramSocket 构造方法：

    DatagramSocket 方法：  

    3.2 DatagramPacket API

    DatagramPacket 是 UDP Socket 发送和接收的数据报。
    DatagramPacket 构造方法：

    DatagramPacket 方法：

            构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创建。

    3.3 InetSocketAddress API

    InetSocketAddress （ SocketAddress 的子类 ）构造方法：

    3.4 示例一：一发一收（无响应）

            以下为一个客户端一次数据发送，和服务端多次数据接收（一次发送一次接收，可以接收多次），即只有客户端请求，但没有服务端响应的示例：
    UDP 服务端 
    1. package org.example.udp.demo1;
    2. import java.io.IOException;
    3. import java.net.DatagramPacket;
    4. import java.net.DatagramSocket;
    5. import java.util.Arrays;
    6. public class UdpServer {
    7.     //服务器socket要绑定固定的端口
    8.     private static final int PORT = 8888;
    9.     public static void main(String[] args) throws IOException {
    10.         // 1.创建服务端DatagramSocket，指定端口，可以发送及接收UDP数据报
    11.         DatagramSocket socket = new DatagramSocket(PORT);
    12.         //不停的接收客户端udp数据报
    13.         while (true){
    14.             // 2.创建数据报，用于接收客户端发送的数据
    15.             byte[] bytes = new byte[1024];//1m=1024kb, 1kb=1024byte, UDP最多
    16. 64k（包含UDP首部8byte）
    17.             DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
    18.             System.out.println("------------------------------------------------
    19. ---");
    20.             System.out.println("等待接收UDP数据报...");
    21.             // 3.等待接收客户端发送的UDP数据报，该方法在接收到数据报之前会一直阻塞，接收到数
    22. 据报以后，DatagramPacket对象，包含数据（bytes）和客户端ip、端口号
    23.             socket.receive(packet);
    24.             System.out.printf("客户端IP：%s%n", 
    25. packet.getAddress().getHostAddress());
    26.             System.out.printf("客户端端口号：%s%n", packet.getPort());
    27.             System.out.printf("客户端发送的原生数据为：%s%n", 
    28. Arrays.toString(packet.getData()));
    29.             System.out.printf("客户端发送的文本数据为：%s%n", new
    30. String(packet.getData()));
    31.        }
    32.    }
    33. }
    运行后，服务端就启动了，控制台输出如下：
    ---------------------------------------------------
    等待接收 UDP 数据报 ...
    可以看出，此时代码是阻塞等待在 socket.receive(packet) 代码行，直到接收到一个 UDP 数据报。
    UDP 客户端 
    1. package org.example.udp.demo1;
    2. import java.io.IOException;
    3. import java.net.DatagramPacket;
    4. import java.net.DatagramSocket;
    5. import java.net.InetSocketAddress;
    6. import java.net.SocketAddress;
    7. public class UdpClient {
    8.     // 服务端socket地址，包含域名或IP，及端口号
    9.     private static final SocketAddress ADDRESS = new
    10. InetSocketAddress("localhost", 8888);
    11.     public static void main(String[] args) throws IOException {
    12.         // 4.创建客户端DatagramSocket，开启随机端口就行，可以发送及接收UDP数据报
    13.         DatagramSocket socket = new DatagramSocket();
    14.         // 5-1.准备要发送的数据
    15.         byte[] bytes = "hello world!".getBytes();
    16.         // 5-2.组装要发送的UDP数据报，包含数据，及发送的服务端信息（服务器IP+端口号）
    17.         DatagramPacket packet = new DatagramPacket(bytes, bytes.length, 
    18. ADDRESS);
    19.         // 6.发送UDP数据报
    20.         socket.send(packet);
    21.    }
    22. }
            客户端启动后会发送一个"hello world!" 的字符串到服务端，在服务端接收后，控制台输出内容如下：
    ---------------------------------------------------
    等待接收 UDP 数据报 ...
    客户端 IP ： 127 . 0.0 . 1
    客户端端口号： 57910
    客户端发送的原生数据为： [ 104 , 101 , 108 , 108 , 111 , 32 , 119 , 111 , 114 , 108 , 100 , 33 ,
    0 , 0 , 0 , ... 此处省略很多 0 ]
    客户端发送的文本数据为： hello world !                                                
                                                                                   
                                                                                   
                                                                                   
                                                                                   
                                                                                   
                                                                                   
                                                                                   
                                                                                   
                                                                                   
                                                                                   
                                                                                   
                                                                                   
       
    ---------------------------------------------------
    等待接收 UDP 数据报 ...
            从以上可以看出，发送的UDP 数据报（假设发送的数据字节数组长度为 M ），在接收到以后（假设接收的数据字节数组长度为N ）：
    • 1. 如果N>M，则接收的byte[]字节数组中会有很多初始化byte[]的初始值0，转换为字符串就是空白字符；
    • 2. 如果N，则会发生数据部分丢失（可以自己尝试，把接收的字节数组长度指定为比发送的字节数组长度更短）。

            要解决以上问题，就需要发送端和接收端双方约定好一致的协议，如规定好结束的标识或整个数据的长度。

    3.5 示例二：请求响应

            示例一只是客户端请求和服务端接收，并没有包含服务端的返回响应。以下是对应请求和响应的改造：构造一个展示服务端本地某个目录（BASE_PATH ）的下一级子文件列表的服务
    （1）客户端先接收键盘输入，表示要展示的相对路径（相对 BASE_PATH 的路径）
    （2）发送请求：将该相对路径作为数据报发送到服务端
    （3）服务端接收并处理请求：根据该请求数据，作为本地目录的路径，列出下一级子文件及子文件夹
    （4）服务端返回响应：遍历子文件和子文件夹，每个文件名一行，作为响应的数据报，返回给客户端
    （5）客户端接收响应：简单的打印输出所有的响应内容，即文件列表。
            为了解决空字符或长度不足数据丢失的问题，客户端服务端约定好统一的协议：这里简单的设计为ASCII结束字符 \3 表示报文结束。
            以下为整个客户端服务端的交互执行流程：

    以下为服务端和客户端代码：

    UDP 服务端 
    1. package org.example.udp.demo2;
    2. import java.io.File;
    3. import java.io.IOException;
    4. import java.net.DatagramPacket;
    5. import java.net.DatagramSocket;
    6. import java.nio.charset.StandardCharsets;
    7. public class UdpServer {
    8.     //服务器socket要绑定固定的端口
    9.     private static final int PORT = 8888;
    10.     //本地文件目录要展示的根路径
    11.     private static final String BASE_PATH = "E:/TMP";
    12.     public static void main(String[] args) throws IOException {
    13.         // 1.创建服务端DatagramSocket，指定端口，可以发送及接收UDP数据报
    14.         DatagramSocket socket = new DatagramSocket(PORT);
    15.         //不停的接收客户端udp数据报
    16.         while (true){
    17.             // 2.创建数据报，用于接收客户端发送的数据
    18.             byte[] requestData = new byte[1024];//1m=1024kb, 1kb=1024byte, UDP最 多64k（包含UDP首部8byte）
    19.             DatagramPacket requestPacket = new DatagramPacket(requestData, 
    20. requestData.length);
    21.             System.out.println("------------------------------------------------
    22. ---");
    23.             System.out.println("等待接收UDP数据报...");
    24.             // 3.等待接收客户端发送的UDP数据报，该方法在接收到数据报之前会一直阻塞，接收到数
    25. 据报以后，DatagramPacket对象，包含数据（bytes）和客户端ip、端口号
    26.             socket.receive(requestPacket);
    27.             System.out.printf("客户端IP：%s%n", 
    28. requestPacket.getAddress().getHostAddress());
    29.             System.out.printf("客户端端口号：%s%n", requestPacket.getPort());
    30.             // 7.接收到的数据作为请求，根据请求数据执行业务，并返回响应
    31.             for (int i = 0; i < requestData.length; i++) {
    32.                 byte b = requestData[i];
    33.                 if(b == '\3') {
    34.                     // 7-1.读取请求的数据：读取到约定好的结束符（\3），取结束符之前的内容
    35.                     String request = new String(requestData, 0, i);
    36.                     // 7-2.根据请求处理业务：本地目录根路径+请求路径，作为要展示的目录，列
    37. 出下一级子文件
    38.                     //请求的文件列表目录
    39.                     System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH +
    40. request);
    41.                     File dir = new File(BASE_PATH + request);
    42.                     //获取下一级子文件，子文件夹
    43.                     File[] children = dir.listFiles();
    44.                     // 7-3.构造要返回的响应内容：每个文件及目录名称为一行
    45.                     StringBuilder response = new StringBuilder();
    46.                     if(children != null){
    47.                         for (File child : children) {
    48.                             response.append(child.getName()+"\n");
    49.                        }
    50.                    }
    51.                     //响应也要约定结束符
    52.                     response.append("\3");
    53.                     byte[] responseData =
    54. response.toString().getBytes(StandardCharsets.UTF_8);
    55.                     // 7-4.构造返回响应的数据报DatagramPacket，注意接收的客户端数据报包
    56. 含IP和端口号，要设置到响应的数据报中
    57.                     DatagramPacket responsePacket = new
    58. DatagramPacket(responseData, responseData.length, 
    59. requestPacket.getSocketAddress());
    60.                     // 7-5.发送返回响应的数据报
    61.                     socket.send(responsePacket);
    62.                     break;
    63.                }
    64.            }
    65.        }
    66.    }
    67. }
    以上服务端运行结果和示例一是一样的：
    ---------------------------------------------------
    等待接收 UDP 数据报 ...
    UDP 客户端 
    1. package org.example.udp.demo2;
    2. import java.io.IOException;
    3. import java.net.DatagramPacket;
    4. import java.net.DatagramSocket;
    5. import java.net.InetSocketAddress;
    6. import java.net.SocketAddress;
    7. import java.nio.charset.StandardCharsets;
    8. import java.util.Scanner;
    9. public class UdpClient {
    10.     // 服务端socket地址，包含域名或IP，及端口号
    11.     private static final SocketAddress ADDRESS = new
    12. InetSocketAddress("localhost", 8888);
    13.     public static void main(String[] args) throws IOException {
    14.         // 4.创建客户端DatagramSocket，开启随机端口就行，可以发送及接收UDP数据报
    15.         DatagramSocket socket = new DatagramSocket();
    16.         // 5-1.准备要发送的数据：这里调整为键盘输入作为发送的内容
    17.         Scanner scanner = new Scanner(System.in);
    18.         while(true){
    19.             System.out.println("------------------------------------------------
    20. ---");
    21.             System.out.println("请输入要展示的目录：");
    22.             // 5-2.每输入新行（回车），就作为UDP发送的数据报，为了接收端获取有效的内容（去除
    23. 空字符串），约定\3为结束
    24.             String request = scanner.nextLine() + "\3";
    25.             byte[] requestData = request.getBytes(StandardCharsets.UTF_8);
    26.             // 5-3.组装要发送的UDP数据报，包含数据，及发送的服务端信息（服务器IP+端口号）
    27.             DatagramPacket requestPacket = new DatagramPacket(requestData, 
    28. requestData.length, ADDRESS);
    29.             // 6.发送UDP数据报
    30.             socket.send(requestPacket);
    31.             // 8.接收服务端响应的数据报，并根据响应内容决定下个步骤（我们这里简单的打印即可）
    32.             // 8-1.创建数据报，用于接收服务端返回（发送）的响应
    33.             byte[] responseData = new byte[1024];
    34.             DatagramPacket responsePacket = new DatagramPacket(responseData, 
    35. responseData.length);
    36.             // 8-2.接收响应数据报
    37.             socket.receive(responsePacket);
    38.             System.out.println("该目录下的文件列表为：");
    39.             // byte[]下次解析的起始位置
    40.             int next = 0;
    41.             for (int i = 0; i < responseData.length; i++) {
    42.                 byte b = responseData[i];
    43.                 if(b == '\3')//结束符退出
    44.                     break;
    45.                 if(b == '\n'){//换行符时进行解析
    46.                     //起始位置到换行符前一个索引位置为要解析的内容
    47.                     String fileName = new String(responseData, next, i-next);
    48.                     System.out.println(fileName);
    49.                     //下次解析从换行符后一个索引开始
    50.                     next = i+1;
    51.                }
    52.            }
    53.        }
    54.    }
    55. }
    客户端启动后会等待输入要展示的路径：
    ---------------------------------------------------
    请输入要展示的目录：
    在输入想查看的目录路径后，会接收并打印服务端响应的文件列表数据：
    ---------------------------------------------------
    请输入要展示的目录：
    /
    该目录下的文件列表为：
    1
    2
    60441 b1b8a74be3695ccc0d970693815
    8f25103 aa249707ee4ab17635142cd0e
    ---------------------------------------------------
    请输入要展示的目录：
    此时服务端也会打印接收到的客户端请求数据：
    ---------------------------------------------------
    等待接收 UDP 数据报 ...
    客户端 IP ： 127 . 0.0 . 1
    客户端端口号： 57297
    客户端请求的文件列表路径为： E : / TMP /
    ---------------------------------------------------
    等待接收 UDP 数据报 ...

    4、TCP流套接字编程

            和刚才UDP 类似 . 实现一个简单的英译汉的功能

    4.1 ServerSocket API

    ServerSocket 是创建 TCP 服务端 Socket 的 API 。
    ServerSocket 构造方法：

     ServerSocket 方法：

    4.2 Socket API

            Socket 是客户端 Socket ，或服务端中接收到客户端建立连接（ accept 方法）的请求后，返回的服务端Socket。不管是客户端还是服务端Socket ，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
            Socket 构造方法：

             Socket 方法：

    4.3 TCP中的长短连接

            TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：
    • 短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
    • 长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。
    对比以上长短连接，两者区别如下：
    • 建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
    • 主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。
    • 两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。
    扩展了解：基于BIO（同步阻塞IO ）的长连接会一直占用系统资源。对于并发要求很高的服务端系统来说，这样的消耗是不能承受的。
            由于每个连接都需要不停的阻塞等待接收数据，所以每个连接都会在一个线程中运行。一次阻塞等待对应着一次请求、响应，不停处理也就是长连接的特性：一直不关闭连接，不停的处理请求。实际应用时，服务端一般是基于NIO（即同步非阻塞IO）来实现长连接，性能可以极大的提升。

    4.4 示例一：一发一收（短连接）

            以下为一个客户端一次数据发送，和服务端多次数据接收（一次发送一次接收，可以接收多次），即只有客户端请求，但没有服务端响应的示例：
    TCP 服务端 
    1. package org.example.tcp.demo1;
    2. import java.io.*;
    3. import java.net.ServerSocket;
    4. import java.net.Socket;
    5. public class TcpServer {
    6.     //服务器socket要绑定固定的端口
    7.     private static final int PORT = 8888;
    8.     public static void main(String[] args) throws IOException {
    9.         // 1.创建一个服务端ServerSocket，用于收发TCP报文
    10.         ServerSocket server = new ServerSocket(PORT);
    11.         // 不停的等待客户端连接
    12.         while(true) {
    13.             System.out.println("------------------------------------------------
    14. ---");
    15.             System.out.println("等待客户端建立TCP连接...");
    16.             // 2.等待客户端连接，注意该方法为阻塞方法
    17.             Socket client = server.accept();
    18.             System.out.printf("客户端IP：%s%n", 
    19. client.getInetAddress().getHostAddress());
    20.             System.out.printf("客户端端口号：%s%n", client.getPort());
    21.             // 5.接收客户端的数据，需要从客户端Socket中的输入流获取
    22.             System.out.println("接收到客户端请求：");
    23.             InputStream is = client.getInputStream();
    24.             // 为了方便获取字符串内容，可以将以上字节流包装为字符流
    25.             BufferedReader br = new BufferedReader(new InputStreamReader(is, 
    26. "UTF-8"));
    27.             String line;
    28.             // 一直读取到流结束：TCP是基于流的数据传输，一定要客户端关闭Socket输出流才表示服
    29. 务端接收IO输入流结束
    30.             while ((line = br.readLine()) != null) {
    31.                 System.out.println(line);
    32.            }
    33.             // 6.双方关闭连接：服务端是关闭客户端socket连接
    34.             client.close();
    35.        }
    36.    }
    37. }
    运行后，服务端就启动了，控制台输出如下：
    ---------------------------------------------------
    等待客户端建立 TCP 连接 ...
    可以看出，此时代码是阻塞等待在 server.accept() 代码行，直到有新的客户端申请建立连接。
    TCP 客户端 
    1. package org.example.tcp.demo1;
    2. import java.io.*;
    3. import java.net.Socket;
    4. public class TcpClient {
    5.     //服务端IP或域名
    6.     private static final String SERVER_HOST = "localhost";
    7.     //服务端Socket进程的端口号
    8.     private static final int SERVER_PORT = 8888;
    9.     public static void main(String[] args) throws IOException {
    10.         // 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接
    11.         Socket client = new Socket(SERVER_HOST, SERVER_PORT);
    12.         // 4.发送TCP数据，是通过socket中的输出流进行发送
    13.         OutputStream os = client.getOutputStream();
    14.         // 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
    15.         PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
    16.         // 4-1.发送数据：
    17.         pw.println("hello world!");
    18.         // 4-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
    19.         pw.flush();
    20.         // 7.双方关闭连接：客户端关闭socket连接
    21.         client.close();
    22.    }
    23. }
    客户端启动后会发送一个 "hello world!" 的字符串到服务端，在服务端接收后，控制台输出内容如下：
    ---------------------------------------------------
    等待客户端建立 TCP 连接 ...
    客户端 IP ： 127 . 0.0 . 1
    客户端端口号： 51118
    接收到客户端请求：
    hello world !
    ---------------------------------------------------
    等待客户端建立 TCP 连接...
            以上客户端与服务端建立的为短连接，每次客户端发送了TCP 报文，及服务端接收了 TCP 报文后，双方都会关闭连接。

    4.5 示例二：请求响应（短连接）

            示例一只是客户端请求和服务端接收，并没有包含服务端的返回响应。以下是对应请求和响应的改造：构造一个展示服务端本地某个目录（BASE_PATH）的下一级子文件列表的服务
    （1）客户端先接收键盘输入，表示要展示的相对路径（相对 BASE_PATH 的路径）
    （2）发送请求：使用客户端 Socket 的输出流发送 TCP 报文。即输入的相对路径。
    （3）服务端接收并处理请求：使用服务端 Socket 的输入流来接收请求报文，根据请求的路径，列出下一级子文件及子文件夹。
    （4）服务端返回响应：使用服务端 Socket 的输出流来发送响应报文。即遍历子文件和子文件夹，每个文件名一行，返回给客户端。
    （5）客户端接收响应：使用客户端 Socket 的输入流来接收响应报文。简单的打印输出所有的响应内容，即文件列表。
    以下为服务端和客户端代码：
    TCP 服务端 
    1. package org.example.tcp.demo2;
    2. import java.io.*;
    3. import java.net.ServerSocket;
    4. import java.net.Socket;
    5. public class TcpServer {
    6.     //服务器socket要绑定固定的端口
    7.     private static final int PORT = 8888;
    8.     //本地文件目录要展示的根路径
    9.     private static final String BASE_PATH = "E:/TMP";
    10.     public static void main(String[] args) throws IOException {
    11.         // 1.创建一个服务端ServerSocket，用于收发TCP报文
    12.         ServerSocket server = new ServerSocket(PORT);
    13.         // 不停的等待客户端连接
    14.         while(true) {
    15.             System.out.println("------------------------------------------------
    16. ---");
    17.             System.out.println("等待客户端建立TCP连接...");
    18.             // 2.等待客户端连接，注意该方法为阻塞方法
    19.             Socket socket = server.accept();
    20.             System.out.printf("客户端IP：%s%n", 
    21. socket.getInetAddress().getHostAddress());
    22.             System.out.printf("客户端端口号：%s%n", socket.getPort());
    23.             // 5.接收客户端的数据，需要从客户端Socket中的输入流获取
    24.             InputStream is = socket.getInputStream();
    25.             // 为了方便获取字符串内容，可以将以上字节流包装为字符流
    26.             BufferedReader br = new BufferedReader(new InputStreamReader(is, 
    27. "UTF-8"));
    28.             // 客户端请求只发送一行数据，我们也只需要读取一行
    29.             String request = br.readLine();
    30.             // 6.根据请求处理业务：本地目录根路径+请求路径，作为要展示的目录，列出下一级子文
    31. 件
    32.             //请求的文件列表目录
    33.             System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH +
    34. request);
    35.             File dir = new File(BASE_PATH + request);
    36.             //获取下一级子文件，子文件夹
    37.             File[] children = dir.listFiles();
    38.             // 7.返回响应给客户端：通过客户端socket中的输出流发送响应数据
    39.             OutputStream os = socket.getOutputStream();
    40.             // 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
    41.             PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-
    42. 8"));
    43.             // 7-1.返回的响应内容：每个文件及目录名称为一行
    44.             if(children != null){
    45.                 for (File child : children) {
    46.                     pw.println(child.getName());
    47.                }
    48.            }
    49.             // 7-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
    50.             pw.flush();
    51.             // 7-3.双方关闭连接：服务端是关闭客户端socket连接
    52.             socket.close();
    53.        }
    54.    }
    55. }
    以上服务端运行结果和示例一是一样的：
    ---------------------------------------------------
    等待客户端建立 TCP 连接 ...
    TCP 客户端 
    1. package org.example.tcp.demo2;
    2. import java.io.*;
    3. import java.net.Socket;
    4. import java.util.Scanner;
    5. public class TcpClient {
    6.     //服务端IP或域名
    7.     private static final String SERVER_HOST = "localhost";
    8.     //服务端Socket进程的端口号
    9.     private static final int SERVER_PORT = 8888;
    10.     public static void main(String[] args) throws IOException {
    11.         // 准备要发送的数据：这里调整为键盘输入作为发送的内容
    12.         Scanner scanner = new Scanner(System.in);
    13.         while(true) {
    14.             System.out.println("------------------------------------------------
    15. ---");
    16.             System.out.println("请输入要展示的目录：");
    17.             // 每输入新行（回车），就作为发送的TCP请求报文
    18.             String request = scanner.nextLine();
    19.             // 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接
    20.             Socket socket = new Socket(SERVER_HOST, SERVER_PORT);
    21.             // 4.发送TCP数据，是通过socket中的输出流进行发送
    22.             OutputStream os = socket.getOutputStream();
    23.             // 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
    24.             PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-
    25. 8"));
    26.             // 4-1.发送数据：
    27.             pw.println(request);
    28.             // 4-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
    29.             pw.flush();
    30.             // 8.接收返回的响应数据：通过socket中的输入流获取
    31.             System.out.println("接收到服务端响应：");
    32.             InputStream is = socket.getInputStream();
    33.             // 为了方便获取字符串内容，可以将以上字节流包装为字符流
    34.             BufferedReader br = new BufferedReader(new InputStreamReader(is, 
    35. "UTF-8"));
    36.             String line;
    37.             // 一直读取到流结束：TCP是基于流的数据传输，一定要服务端关闭Socket输出流才表示客
    38. 户端接收的IO输入流结束
    39.             while ((line = br.readLine()) != null) {
    40.                 System.out.println(line);
    41.            }
    42.             // 9.双方关闭连接：客户端关闭socket连接
    43.             socket.close();
    44.        }
    45.    }
    46. }
    客户端启动后会等待输入要展示的路径：
    ---------------------------------------------------
    请输入要展示的目录：
    在输入想查看的目录路径后，会接收并打印服务端响应的文件列表数据：
    ---------------------------------------------------
    请输入要展示的目录：
    /
    接收到服务端响应：
    1
    2
    60441 b1b8a74be3695ccc0d970693815
    8f25103 aa249707ee4ab17635142cd0e
    ---------------------------------------------------
    请输入要展示的目录：
    此时服务端也会打印接收到的客户端请求数据：
    ---------------------------------------------------
    等待客户端建立 TCP 连接 ...
    客户端 IP ： 127 . 0.0 . 1
    客户端端口号： 52493
    客户端请求的文件列表路径为： E : / TMP /
    ---------------------------------------------------
    等待客户端建立 TCP 连接 ...
    目前 TCP 客户端和服务端实现的功能和 UDP 差不多，但都存在几个问题：
    • 对于服务端来说，处理一次请求并返回响应后，才能再次处理下一次请求和响应，效率是比较低的。这个问题比较好解决：可以使用多线程，每次的请求与响应都在线程中处理。这样多个客户端请求的话，可以在多个线程中并发并行的执行。
    • 服务端解析请求，是只读取了一行，而客户端解析响应，是一直读取到流结束。可以想想为什么解析请求时，没有读取到流结束？
            目前的业务，双方都已约定好业务是展示目录下的文件列表，且都只需要一种数据：请求传输的数据代表要展示的目录；响应传输的数据代表文件列表：每一行为一个文件名。如要提供更多的业务，如文件重命名，文件删除等操作时，就不能了。此时就需要提供更多的字段来标识。一般我们需要设计更强大的协议。

    4.6 再谈协议

    回顾并理解为什么需要协议
            以上我们实现的UDP 和 TCP 数据传输，除了 UDP 和 TCP 协议外，程序还存在应用层自定义协议，可以想想分别都是什么样的协议格式。
            对于客户端及服务端应用程序来说，请求和响应，需要约定一致的数据格式：
    • 客户端发送请求和服务端解析请求要使用相同的数据格式。
    • 服务端返回响应和客户端解析响应也要使用相同的数据格式。
    • 请求格式和响应格式可以相同，也可以不同。
    • 约定相同的数据格式，主要目的是为了让接收端在解析的时候明确如何解析数据中的各个字段。
    • 可以使用知名协议（广泛使用的协议格式），如果想自己约定数据格式，就属于自定义协议。
    封装 / 分用 vs 序列化 / 反序列化
            一般来说，在网络数据传输中，发送端应用程序，发送数据时的数据转换（如java 一般就是将对象转换为某种协议格式），即对发送数据时的数据包装动作 来说：
    • 如果是使用知名协议，这个动作也称为封装
    • 如果是使用小众协议（包括自定义协议），这个动作也称为序列化，一般是将程序中的对象转换为特定的数据格式。
    接收端应用程序，接收数据时的数据转换，即对 接收数据时的数据解析动作 来说：
    • 如果是使用知名协议，这个动作也称为分用
    • 如果是使用小众协议（包括自定义协议），这个动作也称为反序列化，一般是基于接收数据特定的格式，转换为程序中的对象
    如何设计协议
            对于协议来说，重点需要约定好如何解析，一般是根据字段的特点来设计协议：
    对于定长的字段：
    • 可以基于长度约定，如int字段，约定好4个字节即可
    对于不定长的字段：
    • 可以约定字段之间的间隔符，或最后一个字段的结束符，如换行符间隔，\3符号结束等等
    • 除了该字段“数据”本身，再加一个长度字段，用来标识该“数据”长度；即总共使用两个字段：
            “数据 ” 字段本身，不定长，需要通过 “ 长度 ” 字段来解析；
            “长度 ” 字段，标识该 “ 数据 ” 的长度，即用于辅助解析 “ 数据 ” 字段；

    4.7 示例三：多线程+自定义协议

    以下我们将示例二的业务做以下扩展：
    • 提供多种操作：展示目录下文件列表，文件重命名，删除文件，上传文件，下载文件
    • 在不同的操作中，需要抽象出请求和响应的字段，也即是说，要约定客户端服务端统一的请求协议，同时也要约定服务端与客户端统一的响应协议
    本示例中的自定义协议
    以下为我们 TCP 请求数据的协议格式，这里简单起见，约定为换行符及结束符：
    请求类型
    操作的文件或目录路径
    数据\3
    说明如下：
    • 以上总共包含3个字段，前2个字段需要按换行符读取，最后一个字段需要按结束符读取
    • 请求类型标识是什么操作：展示目录下文件列表，文件重命名，删除文件，上传文件，下载文件
    • 重命名、上传文件操作，需要“数据”字段，其他操作可以置为空字符串
    • “数据”字段为最后一个字段，使用\3结束符，这样在数据本身有换行符也能正确处理
    以下为响应数据的协议格式：
    状态码（标识是否操作成功）
    数据（展示列表时，返回目录下的文件列表，或下载文件的数据）\3
    以下为展示文件列表操作的自定义协议（请求、响应格式）
            以下操作将展示服务端根目录下的子文件及子文件夹：

    请求数据格式如下：

    1
    /
    \3
    响应数据格式如下：
    200
    \1
    \2
    \3
    \1.txt
    \2.txt\3
    以下为上传文件操作的自定义协议（请求、响应格式）
            需要先在客户端指定上传的服务端目录，及客户端要上传的文件路径，以下操作将会把客户端Main.java 文件内容上传到服务端根目录 E:/TMP 下的 /1 目录下：

    请求数据格式如下：
    4
    /1
    package org.example;
    public class Main {
    …… 略
    }\3
    响应数据格式如下：
    200
    \3

    执行流程

            约定好请求和响应的数据格式，也就是应用层协议，大家按照约定好的格式来发送和接收，以下为执行流程

    代码实现如下：

    请求类
    先按照约定的请求协议封装请求类：
    • 每个字段为一个属性：操作类型，操作路径，数据
    • 完成服务端解析请求封装：按约定的方式读，先按行读取前2个字段，再按结束符读第3个字段
    • 完成客户端发送请求封装：按约定的方式写，前2个字段按行输出，第3个字段以\3结束 
    1. package org.example.tcp.demo3;
    2. import java.io.*;
    3. import java.util.ArrayList;
    4. import java.util.List;
    5. public class Request {
    6.     //操作类型：1（展示目录文件列表），2（文件重命名），3（删除文件），4（上传文件），5（下载
    7. 文件）
    8.     private Integer type;
    9.     //操作的目录路径
    10.     private String url;
    11.     //数据
    12.     private String data;
    13.     //服务端解析请求时：根据约定好的格式来解析
    14.     public static Request serverParse(InputStream is) throws IOException {
    15.         BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-
    16. 8"));
    17.         Request request = new Request();
    18.         //前2行分别为操作类型和操作路径
    19.         request.type = Integer.parseInt(br.readLine());
    20.         request.url = br.readLine();
    21.         //使用list保存字符
    22.         List list = new ArrayList<>();
    23.         //数据：循环读取
    24.         while(true){
    25.             //一个字符一个字符的读
    26.             char c = (char) br.read();
    27.             //一直读取到结束符\3
    28.             if(c == '\3')
    29.                 break;
    30.             list.add(c);
    31.        }
    32.         //拼接数据
    33.         StringBuilder sb = new StringBuilder();
    34.         for (char c : list){
    35.             sb.append(c);
    36.        }
    37.         request.data = sb.toString();
    38.         return request;
    39.    }
    40.     //客户端发送请求到服务端
    41.     public void clientWrite(OutputStream os) throws IOException {
    42.         PrintWriter pw = new PrintWriter(os);
    43.         pw.println(type);
    44.         pw.println(url);
    45.         pw.write(data+"\3");
    46.         // 4-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
    47.         pw.flush();
    48.    }
    49.     @Override
    50.     public String toString() {
    51.         return "Request{" +
    52.                 "type=" + type +
    53.                 ", url='" + url + '\'' +
    54.                 ", data='" + data + '\'' +
    55.                 '}';
    56.    }
    57.     public Integer getType() {
    58.         return type;
    59.    }
    60.     public void setType(Integer type) {
    61.         this.type = type;
    62.    }
    63.     public String getUrl() {
    64.         return url;
    65.    }
    66.     public void setUrl(String url) {
    67.         this.url = url;
    68.    }
    69.     public String getData() {
    70.         return data;
    71.    }
    72.     public void setData(String data) {
    73.         this.data = data;
    74.    }
    75. }
    响应类
    按照约定的响应协议封装响应类：
    • 每个字段为一个属性：响应状态码
    • 完成客户端解析响应封装：按约定的方式读，先按行读取第1个字段，再按结束符读第2个字段
    • 完成服务端发送响应封装：按约定的方式写，第1个字段按行输出，第2个字段以\3结束 
    1. package org.example.tcp.demo3;
    2. import java.io.*;
    3. import java.util.ArrayList;
    4. import java.util.List;
    5. public class Response {
    6.     //响应的状态码，200表示操作成功，404表示没有找到该路径的文件或目录
    7.     private int status;
    8.     //数据
    9.     private String data;
    10.     //客户端解析服务端返回的响应数据
    11.     public static Response clientParse(InputStream is) throws IOException {
    12.         BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-
    13. 8"));
    14.         Response response = new Response();
    15.         response.status = Integer.parseInt(br.readLine());
    16.         //使用list保存字符
    17.         List list = new ArrayList<>();
    18.         //数据：循环读取
    19.         while(true){
    20.             //一个字符一个字符的读
    21.             char c = (char) br.read();
    22.             //一直读取到结束符\3
    23.             if(c == '\3')
    24.                 break;
    25.             list.add(c);
    26.        }
    27.         //拼接数据
    28.         StringBuilder sb = new StringBuilder();
    29.         for (char c : list){
    30.             sb.append(c);
    31.        }
    32.         response.data = sb.toString();
    33.         return response;
    34.    }
    35.     //服务端返回响应给客户端
    36.     public void serverWrite(OutputStream os) throws IOException {
    37.         PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
    38.         pw.println(status);
    39.         pw.write(data+"\3");
    40.         // 4-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
    41.         pw.flush();
    42.    }
    43.     @Override
    44.     public String toString() {
    45.         return "Response{" +
    46.                 "status=" + status +
    47.                 ", data='" + data + '\'' +
    48.                 '}';
    49.    }
    50.     public int getStatus() {
    51.         return status;
    52.    }
    53.     public void setStatus(int status) {
    54.         this.status = status;
    55.    }
    56.     public String getData() {
    57.         return data;
    58.    }
    59.     public void setData(String data) {
    60.         this.data = data;
    61.    }
    62. }
    TCP 服务端
    以下完成服务端代码：
    • ServerSocket.accept() 为建立客户端服务端连接的方法，为提高效率，使用多线程
    • 先要解析请求数据，即 Request 已封装好的服务端解析请求，返回 Request 对象
    • 返回响应数据，需要根据不同的请求字段，做不同的业务处理，并返回对应的响应内容
            如果操作的url路径再服务端根目录 E:/TMP 下找不到，则返回响应状态码 404
            正常执行完，返回200 响应状态码；要注意根据不同操作类型来执行不同的业务 
    1. package org.example.tcp.demo3;
    2. import java.io.*;
    3. import java.net.ServerSocket;
    4. import java.net.Socket;
    5. import java.nio.file.Files;
    6. import java.util.UUID;
    7. public class TcpServer {
    8.     //服务器socket要绑定固定的端口
    9.     private static final int PORT = 8888;
    10.     //本地文件目录要展示的根路径
    11.     private static final String BASE_PATH = "E:/TMP";
    12.     public static void main(String[] args) throws IOException {
    13.         // 1.创建一个服务端ServerSocket，用于收发TCP报文
    14.         ServerSocket server = new ServerSocket(PORT);
    15.         // 不停的等待客户端连接
    16.         while(true) {
    17.             // 2.等待客户端连接，注意该方法为阻塞方法
    18.             Socket socket = server.accept();
    19.             new Thread(new Runnable() {
    20.                 @Override
    21.                 public void run() {
    22.                     try {
    23.                         System.out.println("------------------------------------
    24. ---------------");
    25.                         System.out.println("客户端建立TCP连接...");
    26.                         System.out.printf("客户端IP：%s%n", 
    27. socket.getInetAddress().getHostAddress());
    28.                         System.out.printf("客户端端口号：%s%n", socket.getPort());
    29.                         // 5.接收客户端的数据，需要从客户端Socket中的输入流获取
    30.                         InputStream is = socket.getInputStream();
    31.                         // 解析为请求对象
    32.                         Request request = Request.serverParse(is);
    33.                         System.out.println("服务端收到请求："+request);
    34.                         // 6.根据请求处理业务：处理完成返回响应对象
    35.                         Response response = build(request);
    36.                         // 7.返回响应给客户端：通过客户端socket中的输出流发送响应数据
    37.                         OutputStream os = socket.getOutputStream();
    38.                         // 7-1.返回的响应内容：按照约定格式输出响应对象中的内容
    39.                         System.out.println("服务端返回响应："+response);
    40.                         response.serverWrite(os);
    41.                         // 7-3.双方关闭连接：服务端是关闭客户端socket连接
    42.                         socket.close();
    43.                    } catch (IOException e) {
    44.                         e.printStackTrace();
    45.                    }
    46.                }
    47.            }).start();
    48.        }
    49.    }
    50.     //根据请求处理业务，返回响应对象
    51.     public static Response build(Request request){
    52.         Response response = new Response();
    53.         response.setStatus(200);
    54.         File url = new File(BASE_PATH+request.getUrl());
    55.         //该路径的文件或目录不存在
    56.         if(!url.exists()){
    57.             response.setStatus(404);
    58.             response.setData("");
    59.             return response;
    60.        }
    61.         try {
    62.             switch (request.getType()){
    63.                 //1展示目录文件列表
    64.                 case 1: {
    65.                     File[] children = url.listFiles();
    66.                     if(children == null){
    67.                         response.setData("");
    68.                    }else{
    69.                         //拼接要返回的数据：文件列表
    70.                         StringBuilder sb = new StringBuilder();
    71.                         for (int i = 0; i < children.length; i++) {
    72.                             File child = children[i];
    73.                             //文件路径截取掉服务端本地路径前缀
    74.                            
    75. sb.append(child.getAbsolutePath().substring(BASE_PATH.length())+"\n");
    76.                        }
    77.                         response.setData(sb.toString());
    78.                    }
    79.                     break;
    80.                }
    81.                 //2文件重命名
    82.                 case 2: {
    83.                     url.renameTo(new
    84. File(url.getParent()+File.separator+request.getData()));
    85.                     break;
    86.                }
    87.                 //3删除文件
    88.                 case 3: {
    89.                     url.delete();
    90.                     break;
    91.                }
    92.                 //上传文件
    93.                 case 4: {
    94.                     //上传到请求的操作路径目录下，保存的文件名简单的以随机字符串uuid生成即
    95. 可
    96.                     FileWriter upload = new
    97. FileWriter(url.getAbsolutePath()+File.separator+ UUID.randomUUID());
    98.                     upload.write(request.getData());
    99.                     upload.flush();
    100.                     upload.close();
    101.                     break;
    102.                }
    103.                 //下载文件
    104.                 case 5: {
    105.                     String data = new String(Files.readAllBytes(url.toPath()));
    106.                     response.setData(data);
    107.                     break;
    108.                }
    109.            }
    110.        } catch (IOException e) {
    111.             e.printStackTrace();
    112.        }
    113.         return response;
    114.    }
    115. }
    TCP 客户端
    以下为客户端代码：
    • 先要建立和服务端的连接，连接服务端的IP和端口
    • 根据输入来构建请求数据：
            先接收操作类型和操作路径
            重命名操作时，需要指定修改的文件名
            文件上传操作时，需要指定上传的客户端本地文件路径
    • 解析响应数据，并根据响应来执行相应的业务，我们这里暂时简单的解析为 Response 对象，并打印即可 
    1. package org.example.tcp.demo3;
    2. import java.io.*;
    3. import java.net.Socket;
    4. import java.nio.file.Files;
    5. import java.nio.file.Paths;
    6. import java.util.Scanner;
    7. public class TcpClient {
    8.     //服务端IP或域名
    9.     private static final String SERVER_HOST = "localhost";
    10.     //服务端Socket进程的端口号
    11.     private static final int SERVER_PORT = 8888;
    12.     public static void main(String[] args) throws IOException {
    13.         // 准备要发送的数据：这里调整为键盘输入作为发送的内容
    14.         Scanner scanner = new Scanner(System.in);
    15.         while(true) {
    16.             //根据键盘输入构造一个请求对象，包含操作类型，操作路径，长度和数据
    17.             Request request = build(scanner);
    18.             // 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接
    19.             Socket socket = new Socket(SERVER_HOST, SERVER_PORT);
    20.             // 4.发送TCP数据，是通过socket中的输出流进行发送
    21.             OutputStream os = socket.getOutputStream();
    22.             // 4-1.发送请求数据：按照约定的格式输出请求对象中的内容
    23.             System.out.println("客户端发送请求："+request);
    24.             request.clientWrite(os);
    25.             // 8.接收返回的响应数据：通过socket中的输入流获取
    26.             InputStream is = socket.getInputStream();
    27.             // 根据约定的格式获取响应数据
    28.             Response response = Response.clientParse(is);
    29.             System.out.println("客户端收到响应："+response);
    30.             // 9.双方关闭连接：客户端关闭socket连接
    31.             socket.close();
    32.        }
    33.    }
    34.     //客户端发送请求时，根据键盘输入构造一个请求对象
    35.     public static Request build(Scanner scanner) throws IOException {
    36.         System.out.println("---------------------------------------------------
    37. ");
    38.         System.out.println("请输入要操作的类型：1（展示目录文件列表），2（文件重命名），
    39. 3（删除文件），4（上传文件），5（下载文件）");
    40.         Request request = new Request();
    41.         int type = Integer.parseInt(scanner.nextLine());
    42.         System.out.println("请输入要操作的路径：");
    43.         String url = scanner.nextLine();
    44.         String data = "";
    45.         //只需要操作类型和操作路径的请求，长度和数据构造为空的
    46.         if(type == 2){//重命名操作，需要输入重命名的名称
    47.             System.out.println("请输入要重命名的名称：");
    48.             data = scanner.nextLine();
    49.        }else if(type == 4){//文件上传，需要提供上传的文件路径
    50.             System.out.println("请输入要上传的文件路径：");
    51.             String upload = scanner.nextLine();
    52.             data = new String(Files.readAllBytes(Paths.get(upload)));
    53.        }else if(type != 1 && type !=3 && type!=5){
    54.             System.out.println("只能输入1-5的数字，请重新输入");
    55.             return build(scanner);
    56.        }
    57.         request.setType(type);
    58.         request.setUrl(url);
    59.         request.setData(data);
    60.         return request;
    61.    }
    62. }

  • 相关阅读:
    MyBatisPlus又在搞事了，发布神器，一个依赖轻松搞定权限问题？
    靠“山寨”发家的名创优品，如今是什么模样
    HTTP 的三次握手
    pro、pre、test、dev环境
    猿创征文丨赶紧进来!!!带你0距离全面接触 变量和常量
    23种设计模式
    Android样式和主题
    线程安全，这词你懂了吗？
    [附源码]java毕业设计校园志愿者服务管理系统
    GO的继承重写多态反射学习
  • 原文地址：https://blog.csdn.net/weixin_51912875/article/details/126028078