Java网络编程套接字
文章目录
-
- 1、网络编程基础
- 2、什么是网络编程
- 3、网络编程中的基本概念
-
- 3.1、发送端和接收端
- 3.2 请求和响应
- 3.3 客户端和服务端
- 3.4 常见的客户端服务端模型
- 4、Socket套接字
-
- 4.1 概念
- 4.2 分类
- 5、Java数据报套接字通信模型
- 6、Java流套接字通信模型
- 7、Socket编程注意事项
- 8、UDP数据报套接字编程
-
- 8.1 DatagramSocket API
- 8.2 DatagramPacket API
- 8.3 InetSocketAddress API
- 9、TCP流套接字编程
-
- 9.1 ServerSocket API
- 9.2 Socket API
- 9.3 TCP中的长短连接
- 10、协议
-
- 10.1 理解为什么需要协议
- 10.2 封装/分用 vs 序列化/反序列化
- 10.3 如何设计协议
-
- 10.3.1 TCP/IP五层协议
1、网络编程基础
为什么需要网络编程？
丰富的网络资源
用户在浏览器中，打开在线视频网站，观看视频，实质是通过网络，获取到网络上的一个视频资源。
与本地打开视频文件类似，只是视频文件这个资源的来源是网络。
相比本地资源来说，网络提供了更为丰富的网络资源：
所谓的网络资源，其实就是在网络中可以获取的各种数据资源。
而所有的网络资源，都是通过网络编程来进行数据传输的。
2、什么是网络编程
网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）。
我们只要满足进程不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据，也属于网络编程。
特殊的，对于开发来说，在条件有限的情况下，一般也都是在一个主机中运行多个进程来完成网络编程。
但是，我们一定要明确，我们的目的是提供网络上不同主机，基于网络来传输数据资源：
进程A：编程来获取网络资源
进程B：编程来提供网络资源
3、网络编程中的基本概念
3.1、发送端和接收端
在一次网络数据传输时：
发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
**接收端：**数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
**收发端：**发送端和接收端两端，也简称为收发端。
注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念。
3.2 请求和响应
一般来说，获取一个网络资源，涉及到两次网络数据传输：
第一次：请求数据的发送
第二次：响应数据的发送。
举例：
好比在快餐店点一份炒饭：
先要发起请求：点一份炒饭，再有快餐店提供的对应响应：提供一份炒饭
3.3 客户端和服务端
**服务端：**在常见的网络数据传输场景下，把提供服务的一方进程，称为服务端，可以提供对外服务。
**客户端：**获取服务的一方进程，称为客户端。
对于服务来说，一般是提供：
1、客户端获取服务资源
2、客户端保存资源在服务端
举例：
好比在银行办事：
银行提供存款服务：用户（客户端）保存资源（现金）在银行（服务端）
银行提供取款服务：用户（客户端）获取服务端资源（银行替用户保管的现金）
3.4 常见的客户端服务端模型
最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序：
- 客户端先发送请求到服务端
- 服务端根据请求数据，执行相应的业务处理
- 服务端返回响应：发送业务处理结果
- 客户端根据响应数据，展示处理结果（展示获取的资源，或提示保存资源的处理结果）
4、Socket套接字
网络编程套接字，是操作系统给应用程序题供的一组API（叫做socket API），可以视为是应用层和传输层之间的通信桥梁，传输层的核心协议有两种，TCP\UDP，socket API 也有对应的两组，两组API差别也很大
4.1 概念
、Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。
4.2 分类
Socket套接字主要针对传输层协议划分为如下三类：
**流套接字：**使用传输层TCP协议
TCP，即Transmission Control Protocol（传输控制协议），传输层协议。
以下为TCP的特点：
1、有连接
举例：像打电话，得先接通，才能交换信息
2、可靠传输
传输过程中，发送方知道对方有没有收到数据，可靠传输不等于安全传输，例如阿里旺旺
3、面向字节流
以字节为单位进行传输，类似于文件操作中得字节流。
4、有接收缓冲区，也有发送缓冲区
4、大小不限
对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收。
**数据报套接字：**使用传输层UDP协议
UDP，即User Datagram Protocol（用户数据报协议），传输层协议。
以下为UDP的特点：
1、无连接
举例：像发微信，不需要接通，直接就能发送数据
2、不可靠传输
传输过程中，发送方不知道对方有没有收到数据可靠传输不等于安全传输。
3、面向数据报
以数据报为单位进行传输（一个数据报都会明确大小）一次发送/接受必须是一个完整的数据报，不能是半个，也不能是一个。
4、有接收缓冲区，无发送缓冲区
5、大小受限：一次最多传输64k
对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100个字节，必须一次发送，接收也必须一次接收100个字节，而不能分100次，每次接收1个字节。
原始套接字
原始套接字用于自定义传输层协议，用于读写内核没有处理的IP协议数据。
全双工：一条链路，双向通信
单双工：一条链路，单向通信
5、Java数据报套接字通信模型
对于UDP协议来说，具有无连接，面向数据报的特征，即每次都是没有建立连接，并且一次发送全部数据报，一次接收全部的数据报。
java中使用UDP协议通信，主要基于 DatagramSocket 类来创建数据报套接字，并使用DatagramPacket 作为发送或接收的UDP数据报。对于一次发送及接收UDP数据报的流程如下：
以上只是一次发送端的UDP数据报发送，及接收端的数据报接收，并没有返回的数据。也就是只有请求，没有响应。对于一个服务端来说，重要的是提供多个客户端的请求处理及响应，流程如下：
6、Java流套接字通信模型
7、Socket编程注意事项
- 客户端和服务端：开发时，经常是基于一个主机开启两个进程作为客户端和服务端，但真实的场景，一般都是不同主机。
- 注意目的IP和目的端口号，标识了一次数据传输时要发送数据的终点主机和进程
- Socket编程我们是使用流套接字和数据报套接字，基于传输层的TCP或UDP协议，但应用层协议，也需要考虑，这块我们在后续来说明如何设计应用层协议。
- 关于端口被占用的问题
如果一个进程A已经绑定了一个端口，再启动一个进程B绑定该端口，就会报错，这种情况也叫端口被占用。对于java进程来说，端口被占用的常见报错信息如下：
此时需要检查进程B绑定的是哪个端口，再查看该端口被哪个进程占用。以下为通过端口号查进程的方式：
1、在cmd输入 netstat -ano | findstr 端口号 ，则可以显示对应进程的pid。如以下命令显示了8888进程的pid
2、在任务管理器中，通过pid查找进程
解决端口被占用的问题：
1、如果占用端口的进程A不需要运行，就可以关闭A后，再启动需要绑定该端口的进程B。
2、如果需要运行A进程，则可以修改进程B的绑定端口，换为其他没有使用的端口。
8、UDP数据报套接字编程
无连接、不可靠、面向数据报、全双工
8.1 DatagramSocket API
DatagramSocket 是UDP Socket一个类，用于发送和接收UDP数据报。socket文件，就对应“网卡”这种硬件设备，从socket文件读数据，本质就是都网卡，写数据就是写网卡。
DatagramSocket 构造方法：
| 方法签名 | 方法说明 |
|---|---|
| DatagramSocket() | 创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端） |
| DatagramSocket(int port) | 创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端） |
DatagramSocket 方法：
| 方法签名 | 方法说明 |
|---|---|
| void receive(DatagramPacket p) | 从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待） |
| void send(DatagramPacketp) | 从此套接字发送数据报包（不会阻塞等待，直接发送） |
| void close() | 关闭此数据报套接字 |
8.2 DatagramPacket API
DatagramPacket是UDP Socket一个类，发送和接收的数据报。使用UDP传输数据的基本单位。
DatagramPacket 构造方法：
| 方法签名 | 方法说明 |
|---|---|
| DatagramPacket(byte[] buf, int length) | 构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组（第一个参数buf）中，接收指定长度（第二个参数length） |
| DatagramPacket(byte[] buf, int offset, int length,SocketAddress address) | 构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组（第一个参数buf）中，从0到指定长度（第二个参数length）。address指定目的主机的IP和端口号 |
| DatagramPacket 方法： | |
| 方法签名 | 方法说明 |
| – | – |
| InetAddress getAddress() | 从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址 |
| int getPort() | 从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号 |
| byte[] getData() | 获取数据报中的数据 |
构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创建。
8.3 InetSocketAddress API
InetSocketAddress （ SocketAddress 的子类 ）构造方法：
| 方法签名 | 方法说明 |
|---|---|
| InetSocketAddress(InetAddress addr, int port) | 创建一个Socket地址，包含IP地址和端口号 |
示例一：一发一收（无响应）
以下为一个客户端一次数据发送，和服务端多次数据接收（一次发送一次接收，可以接收多次），即只有客户端请求，但没有服务端响应的示例：
UDP服务端
package org.example.udp.demo1;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.Arrays;
public class UdpServer {
//服务器socket要绑定固定的端口
private static final int PORT = 8888;
public static void main(String[] args) throws IOException {
// 1.创建服务端DatagramSocket，指定端口，可以发送及接收UDP数据报
DatagramSocket socket = new DatagramSocket(PORT);
//不停的接收客户端udp数据报
while (true){
// 2.创建数据报，用于接收客户端发送的数据
byte[] bytes = new byte[1024];//1m=1024kb, 1kb=1024byte, UDP最多
64k（包含UDP首部8byte）
DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
System.out.println("------------------------------------------------
---");
System.out.println("等待接收UDP数据报...");
// 3.等待接收客户端发送的UDP数据报，该方法在接收到数据报之前会一直阻塞，接收到数
据报以后，DatagramPacket对象，包含数据（bytes）和客户端ip、端口号
socket.receive(packet);
System.out.printf("客户端IP：%s%n",
packet.getAddress().getHostAddress());
System.out.printf("客户端端口号：%s%n", packet.getPort());
System.out.printf("客户端发送的原生数据为：%s%n",
Arrays.toString(packet.getData()));
System.out.printf("客户端发送的文本数据为：%s%n", new
String(packet.getData()));
}
}
}
运行后，服务端就启动了，控制台输出如下：
---------------------------------------------------
等待接收UDP数据报...
可以看出，此时代码是阻塞等待在 socket.receive(packet) 代码行，直到接收到一个UDP数据报。
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
// 站在服务器的角度:
// 1. 源 IP: 服务器程序本机的 IP
// 2. 源端口: 服务器绑定的端口 (此处手动指定了 9090)
// 3. 目的 IP: 包含在收到的数据报中. (客户端的IP)
// 4. 目的端口: 包含在收到的数据报中. (客户端的端口)
// 5. 协议类型: UDP
public class UdpEchoServer {
// 进行网络编程, 第一步就需要先准备好 socket 实例~ 这是进行网络编程的大前提.
private DatagramSocket socket = null;
public UdpEchoServer(int port) throws SocketException {
socket = new DatagramSocket(port);
}
// 启动服务器.
public void start() throws IOException {
System.out.println("启动服务器!");
// UDP 不需要建立连接, 直接接收从客户端来的数据即可
while (true) {
// 1. 读取客户端发来的请求
DatagramPacket requestPacket = new DatagramPacket(new byte[1024], 1024);
socket.receive(requestPacket); // 为了接受数据, 需要先准备好一个空的 DatagramPacket 对象, 由 receive 来进行填充数据
// 把 DatagramPacket 解析成一个 String
String request = new String(requestPacket.getData(), 0, requestPacket.getLength(), "UTF-8");
// 2. 根据请求计算响应(由于咱们这是一个回显服务, 2 省略)
String response = process(request);
// 3. 把响应写回到客户端
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
requestPacket.getSocketAddress());
socket.send(responsePacket);
System.out.printf("[%s:%d] req: %s, resp: %s\n",
requestPacket.getAddress().toString(), requestPacket.getPort(), request, response);
}
}
// 由于是回显服务, 响应就和请求一样了.
// 实际上对于一个真实的服务器来说, 这个过程是最复杂的. 为了实现这个过程, 可能需要几万行, 几十万行代码....
public String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
UdpEchoServer server = new UdpEchoServer(9090);
server.start();
}
}
客户端启动后会发送一个"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）：
- 如果N>M，则接收的byte[]字节数组中会有很多初始化byte[]的初始值0，转换为字符串就是空白字符；
- 如果N
示例二：请求响应
示例一只是客户端请求和服务端接收，并没有包含服务端的返回响应。以下是对应请求和响应的改造：
构造一个展示服务端本地某个目录（BASE_PATH）的下一级子文件列表的服务
（1）客户端先接收键盘输入，表示要展示的相对路径（相对BASE_PATH的路径）
（2）发送请求：将该相对路径作为数据报发送到服务端。
（3）服务端接收并处理请求：根据该请求数据，作为本地目录的路径，列出下一级子文件及子文件夹。
（4）服务端返回响应：遍历子文件和子文件夹，每个文件名一行，作为响应的数据报，返回给客户端。
（5）客户端接收响应：简单的打印输出所有的响应内容，即文件列表。
为了解决空字符或长度不足数据丢失的问题，客户端服务端约定好统一的协议：这里简单的设计为ASCII结束字符 \3 表示报文结束。
以下为整个客户端服务端的交互执行流程：
以下为服务端和客户端代码：
UDP服务端
package org.example.udp.demo2;
import java.io.File;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;
public class UdpServer {
//服务器socket要绑定固定的端口
private static final int PORT = 8888;
//本地文件目录要展示的根路径
private static final String BASE_PATH = "E:/TMP";
public static void main(String[] args) throws IOException {
// 1.创建服务端DatagramSocket，指定端口，可以发送及接收UDP数据报
DatagramSocket socket = new DatagramSocket(PORT);
//不停的接收客户端udp数据报
while (true){
// 2.创建数据报，用于接收客户端发送的数据
byte[] requestData = new byte[1024];//1m=1024kb, 1kb=1024byte, UDP最
多64k（包含UDP首部8byte）
DatagramPacket requestPacket = new DatagramPacket(requestData,
requestData.length);
System.out.println("------------------------------------------------
---");
System.out.println("等待接收UDP数据报...");
// 3.等待接收客户端发送的UDP数据报，该方法在接收到数据报之前会一直阻塞，接收到数
据报以后，DatagramPacket对象，包含数据（bytes）和客户端ip、端口号
socket.receive(requestPacket);
System.out.printf("客户端IP：%s%n",
requestPacket.getAddress().getHostAddress());
System.out.printf("客户端端口号：%s%n", requestPacket.getPort());
// 7.接收到的数据作为请求，根据请求数据执行业务，并返回响应
for (int i = 0; i < requestData.length; i++) {
byte b = requestData[i];
if(b == '\3') {
// 7-1.读取请求的数据：读取到约定好的结束符（\3），取结束符之前的内容
String request = new String(requestData, 0, i);
// 7-2.根据请求处理业务：本地目录根路径+请求路径，作为要展示的目录，列
出下一级子文件
//请求的文件列表目录
System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH +
request);
File dir = new File(BASE_PATH + request);
//获取下一级子文件，子文件夹
File[] children = dir.listFiles();
// 7-3.构造要返回的响应内容：每个文件及目录名称为一行
StringBuilder response = new StringBuilder();
if(children != null){
for (File child : children) {
response.append(child.getName()+"\n");
}
}
//响应也要约定结束符
response.append("\3");
byte[] responseData =
response.toString().getBytes(StandardCharsets.UTF_8);
// 7-4.构造返回响应的数据报DatagramPacket，注意接收的客户端数据报包
含IP和端口号，要设置到响应的数据报中
DatagramPacket responsePacket = new
DatagramPacket(responseData, responseData.length,
requestPacket.getSocketAddress());
// 7-5.发送返回响应的数据报
socket.send(responsePacket);
break;
}
}
}
}
}
以上服务端运行结果和示例一是一样的：
---------------------------------------------------
等待接收UDP数据报...
```java
package org.example.udp.demo1;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
public class UdpClient {
// 服务端socket地址，包含域名或IP，及端口号
private static final SocketAddress ADDRESS = new
InetSocketAddress("localhost", 8888);
public static void main(String[] args) throws IOException {
// 4.创建客户端DatagramSocket，开启随机端口就行，可以发送及接收UDP数据报
DatagramSocket socket = new DatagramSocket();
// 5-1.准备要发送的数据
byte[] bytes = "hello world!".getBytes();
// 5-2.组装要发送的UDP数据报，包含数据，及发送的服务端信息（服务器IP+端口号）
DatagramPacket packet = new DatagramPacket(bytes, bytes.length,
ADDRESS);
// 6.发送UDP数据报
socket.send(packet);
}
}
UDP客户端
package org.example.udp.demo2;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class UdpClient {
// 服务端socket地址，包含域名或IP，及端口号
private static final SocketAddress ADDRESS = new
InetSocketAddress("localhost", 8888);
public static void main(String[] args) throws IOException {
// 4.创建客户端DatagramSocket，开启随机端口就行，可以发送及接收UDP数据报
DatagramSocket socket = new DatagramSocket();
// 5-1.准备要发送的数据：这里调整为键盘输入作为发送的内容
Scanner scanner = new Scanner(System.in);
while(true){
System.out.println("------------------------------------------------
---");
System.out.println("请输入要展示的目录：");
// 5-2.每输入新行（回车），就作为UDP发送的数据报，为了接收端获取有效的内容（去除
空字符串），约定\3为结束
String request = scanner.nextLine() + "\3";
byte[] requestData = request.getBytes(StandardCharsets.UTF_8);
// 5-3.组装要发送的UDP数据报，包含数据，及发送的服务端信息（服务器IP+端口号）
DatagramPacket requestPacket = new DatagramPacket(requestData,
requestData.length, ADDRESS);
// 6.发送UDP数据报
socket.send(requestPacket);
// 8.接收服务端响应的数据报，并根据响应内容决定下个步骤（我们这里简单的打印即可）
// 8-1.创建数据报，用于接收服务端返回（发送）的响应
byte[] responseData = new byte[1024];
DatagramPacket responsePacket = new DatagramPacket(responseData,
responseData.length);
// 8-2.接收响应数据报
socket.receive(responsePacket);
System.out.println("该目录下的文件列表为：");
// byte[]下次解析的起始位置
int next = 0;
for (int i = 0; i < responseData.length; i++) {
byte b = responseData[i];
if(b == '\3')//结束符退出
break;
if(b == '\n'){//换行符时进行解析
//起始位置到换行符前一个索引位置为要解析的内容
String fileName = new String(responseData, next, i-next);
System.out.println(fileName);
//下次解析从换行符后一个索引开始
next = i+1;
}
}
}
}
}
客户端启动后会等待输入要展示的路径：
---------------------------------------------------
请输入要展示的目录：
在输入想查看的目录路径后，会接收并打印服务端响应的文件列表数据：
---------------------------------------------------
请输入要展示的目录：
/
该目录下的文件列表为：
1
2
60441b1b8a74be3695ccc0d970693815
8f25103aa249707ee4ab17635142cd0e
---------------------------------------------------
请输入要展示的目录：
此时服务端也会打印接收到的客户端请求数据：
---------------------------------------------------
等待接收UDP数据报...
客户端IP：127.0.0.1
客户端端口号：57297
客户端请求的文件列表路径为：E:/TMP/
---------------------------------------------------
等待接收UDP数据报...
```java
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;
public class UdpEchoClient {
private DatagramSocket socket = null;
private String serverIP;
private int serverPort;
// 站在客户端的角度:
// 源 IP: 本机 IP
// 源端口: 系统分配的端口
// 目的 IP: 服务器的 IP
// 目的端口: 服务器的端口
// 协议类型: UDP
public UdpEchoClient(String ip, int port) throws SocketException {
// 此处的 port 是服务器的端口.
// 客户端启动的时候, 不需要给 socket 指定端口. 客户端自己的端口是系统随机分配的~~
socket = new DatagramSocket();
serverIP = ip;
serverPort = port;
}
public void start() throws IOException {
Scanner scanner = new Scanner(System.in);
while (true) {
// 1. 先从控制台读取用户输入的字符串
System.out.print("-> ");
String request = scanner.next();
// 2. 把这个用户输入的内容, 构造成一个 UDP 请求, 并发送.
// 构造的请求里包含两部分信息:
// 1) 数据的内容. request 字符串
// 2) 数据要发给谁~ 服务器的 IP + 端口
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
InetAddress.getByName(serverIP), serverPort);
socket.send(requestPacket);
// 3. 从服务器读取响应数据, 并解析
DatagramPacket responsePacket = new DatagramPacket(new byte[1024], 1024);
socket.receive(responsePacket);
String response = new String(responsePacket.getData(), 0, responsePacket.getLength(), "UTF-8");
// 4. 把响应结果显示到控制台上.
System.out.printf("req: %s, resp: %s\n", request, response);
}
}
public static void main(String[] args) throws IOException {
// 由于服务器和客户端在同一个机器上, 使用的 IP 仍然是 127.0.0.1 . 如果是在不同的机器上, 当然就需要更改这里的 IP 了
UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);
client.start();
}
}
用UDP类似. 实现一个简单的英译汉的功能
import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
public class UdpDictServer extends UdpEchoServer {
private HashMap<String, String> dict = new HashMap<>();
public UdpDictServer(int port) throws SocketException {
super(port);
// 简单构造几个词
dict.put("cat", "小猫");
dict.put("dog", "小狗");
dict.put("fuck", "卧槽");
dict.put("pig", "小猪");
}
@Override
public String process(String request) {
return dict.getOrDefault(request, "该词无法被翻译!");
}
public static void main(String[] args) throws IOException {
UdpDictServer server = new UdpDictServer(9090);
server.start();
}
}
9、TCP流套接字编程
有连接、可靠、面向字节流、全双工
9.1 ServerSocket API
ServerSocket 是创建TCP服务端Socket的API。
ServerSocket 构造方法：
| 方法签名 | 方法说明 |
|---|---|
| ServerSocket(int port) | 创建一个服务端流套接字Socket，并绑定到指定端口 |
ServerSocket 方法：
| 方法签名 | 方法说明 |
|---|---|
| Socket accept() | 开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket对象，并基于该Socket建立与客户端的连接，否则阻塞等待 |
| void close() | 关闭此套接字 |
9.2 Socket API
Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
Socket 构造方法：
| 方法签名 | 方法说明 |
|---|---|
| Socket(String host, int port) | 创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接 |
Socket 方法：
| 方法签名 | 方法说明 |
|---|---|
| InetAddress getInetAddress() | 返回套接字所连接的地址 |
| InputStream getInputStream() | 返回此套接字的输入流 |
| OutputStream getOutputStream() | 返回此套接字的输出流 |
9.3 TCP中的长短连接
TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：
短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。
对比以上长短连接，两者区别如下：
1、建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要
第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
2、主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送
请求，也可以是服务端主动发。
3、两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于
客户端与服务端通信频繁的场景，如聊天室，实时游戏等。
扩展了解：
基于BIO（同步阻塞IO）的长连接会一直占用系统资源。对于并发要求很高的服务端系统来说，这样的
消耗是不能承受的。
由于每个连接都需要不停的阻塞等待接收数据，所以每个连接都会在一个线程中运行。
一次阻塞等待对应着一次请求、响应，不停处理也就是长连接的特性：一直不关闭连接，不停的处理请求。
实际应用时，服务端一般是基于NIO（即同步非阻塞IO）来实现长连接，性能可以极大的提升。
示例一：一发一收（短连接）
以下为一个客户端一次数据发送，和服务端多次数据接收（一次发送一次接收，可以接收多次），即只
有客户端请求，但没有服务端响应的示例：
TCP服务端
package org.example.tcp.demo1;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
//服务器socket要绑定固定的端口
private static final int PORT = 8888;
public static void main(String[] args) throws IOException {
// 1.创建一个服务端ServerSocket，用于收发TCP报文
ServerSocket server = new ServerSocket(PORT);
// 不停的等待客户端连接
while(true) {
System.out.println("------------------------------------------------
---");
System.out.println("等待客户端建立TCP连接...");
// 2.等待客户端连接，注意该方法为阻塞方法
Socket client = server.accept();
System.out.printf("客户端IP：%s%n",
client.getInetAddress().getHostAddress());
System.out.printf("客户端端口号：%s%n", client.getPort());
// 5.接收客户端的数据，需要从客户端Socket中的输入流获取
System.out.println("接收到客户端请求：");
InputStream is = client.getInputStream();
// 为了方便获取字符串内容，可以将以上字节流包装为字符流
BufferedReader br = new BufferedReader(new InputStreamReader(is,
"UTF-8"));
String line;
// 一直读取到流结束：TCP是基于流的数据传输，一定要客户端关闭Socket输出流才表示服
务端接收IO输入流结束
while ((line = br.readLine()) != null) {
System.out.println(line);
}
// 6.双方关闭连接：服务端是关闭客户端socket连接
client.close();
}
}
}
运行后，服务端就启动了，控制台输出如下：
---------------------------------------------------
等待客户端建立TCP连接...
可以看出，此时代码是阻塞等待在 server.accept() 代码行，直到有新的客户端申请建立连接。
TCP客户端
package org.example.tcp.demo1;
import java.io.*;
import java.net.Socket;
public class TcpClient {
//服务端IP或域名
private static final String SERVER_HOST = "localhost";
//服务端Socket进程的端口号
private static final int SERVER_PORT = 8888;
public static void main(String[] args) throws IOException {
// 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接
Socket client = new Socket(SERVER_HOST, SERVER_PORT);
// 4.发送TCP数据，是通过socket中的输出流进行发送
OutputStream os = client.getOutputStream();
// 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
// 4-1.发送数据：
pw.println("hello world!");
// 4-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
pw.flush();
// 7.双方关闭连接：客户端关闭socket连接
client.close();
}
}
客户端启动后会发送一个"hello world!" 的字符串到服务端，在服务端接收后，控制台输出内容如下：
---------------------------------------------------
等待客户端建立TCP连接...
客户端IP：127.0.0.1
客户端端口号：51118
接收到客户端请求：
hello world!
---------------------------------------------------
等待客户端建立TCP连接...
以上客户端与服务端建立的为短连接，每次客户端发送了TCP报文，及服务端接收了TCP报文后，双方
都会关闭连接。
示例二：请求响应（短连接）
示例一只是客户端请求和服务端接收，并没有包含服务端的返回响应。以下是对应请求和响应的改造：
构造一个展示服务端本地某个目录（BASE_PATH）的下一级子文件列表的服务
（1）客户端先接收键盘输入，表示要展示的相对路径（相对BASE_PATH的路径）
（2）发送请求：使用客户端Socket的输出流发送TCP报文。即输入的相对路径。
（3）服务端接收并处理请求：使用服务端Socket的输入流来接收请求报文，根据请求的路径，列出下
一级子文件及子文件夹。
（4）服务端返回响应：使用服务端Socket的输出流来发送响应报文。即遍历子文件和子文件夹，每个
文件名一行，返回给客户端。
（5）客户端接收响应：使用客户端Socket的输入流来接收响应报文。简单的打印输出所有的响应内
容，即文件列表。
以下为服务端和客户端代码：
TCP服务端
package org.example.tcp.demo2;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer {
//服务器socket要绑定固定的端口
private static final int PORT = 8888;
//本地文件目录要展示的根路径
private static final String BASE_PATH = "E:/TMP";
public static void main(String[] args) throws IOException {
// 1.创建一个服务端ServerSocket，用于收发TCP报文
ServerSocket server = new ServerSocket(PORT);
// 不停的等待客户端连接
while(true) {
System.out.println("------------------------------------------------
---");
System.out.println("等待客户端建立TCP连接...");
// 2.等待客户端连接，注意该方法为阻塞方法
Socket socket = server.accept();
System.out.printf("客户端IP：%s%n",
socket.getInetAddress().getHostAddress());
System.out.printf("客户端端口号：%s%n", socket.getPort());
// 5.接收客户端的数据，需要从客户端Socket中的输入流获取
InputStream is = socket.getInputStream();
// 为了方便获取字符串内容，可以将以上字节流包装为字符流
BufferedReader br = new BufferedReader(new InputStreamReader(is,
"UTF-8"));
// 客户端请求只发送一行数据，我们也只需要读取一行
String request = br.readLine();
// 6.根据请求处理业务：本地目录根路径+请求路径，作为要展示的目录，列出下一级子文
件
//请求的文件列表目录
System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH +
request);
File dir = new File(BASE_PATH + request);
//获取下一级子文件，子文件夹
File[] children = dir.listFiles();
// 7.返回响应给客户端：通过客户端socket中的输出流发送响应数据
OutputStream os = socket.getOutputStream();
// 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF8"));
// 7-1.返回的响应内容：每个文件及目录名称为一行
if(children != null){
for (File child : children) {
pw.println(child.getName());
}
}
// 7-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
pw.flush();
// 7-3.双方关闭连接：服务端是关闭客户端socket连接
socket.close();
}
}
}
以上服务端运行结果和示例一是一样的：
---------------------------------------------------
等待客户端建立TCP连接...
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoServer {
// listen => 英文原意 监听~~
// 但是在 Java socket 中是体现不出来 "监听" 的含义的~~
// 之所以这么叫, 其实是 操作系统原生的 API 里有一个操作叫做 listen
// private ServerSocket listenSocket = null;
private ServerSocket serverSocket = null;
public TcpEchoServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("服务器启动!");
while (true) {
// 由于 TCP 是有连接的, 不能一上来就读数据, 而要先建立连接. (接电话)
// accept 就是在 "接电话", 接电话的前提是, 有人给你打了~~, 如果当前没有客户端尝试建立连接, 此处的 accept 就会阻塞.
// accept 返回了 一个 socket 对象, 称为 clientSocket. 后续和客户端之间的沟通, 都是通过 clientSocket 来完成的.
// 进一步讲, serverSocket 就干了一件事, 接电话~~
Socket clientSocket = serverSocket.accept();
processConnection(clientSocket);
}
}
private void processConnection(Socket clientSocket) {
System.out.printf("[%s:%d] 客户端建立连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
// 接下来来处理请求和响应
// 这里的针对 TCP socket 的读写就和文件读写是一模一样的!!
try (InputStream inputStream = clientSocket.getInputStream()) {
try (OutputStream outputStream = clientSocket.getOutputStream()) {
// 循环的处理每个请求, 分别返回响应
Scanner scanner = new Scanner(inputStream);
while (true) {
// 1. 读取请求
if (!scanner.hasNext()) {
System.out.printf("[%s:%d] 客户端断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
break;
}
// 此处用 Scanner 更方便. 如果不用 Scanner 就用原生的 InputStream 的 read 也是可以的
String request = scanner.next();
// 2. 根据请求, 计算响应
String response = process(request);
// 3. 把这个响应返回给客户端
// 为了方便起见, 可以使用 PrintWriter 把 OutputStream 包裹一下
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(response);
// 刷新缓冲区, 如果没有这个刷新, 可能客户端就不能第一时间看到响应结果.
printWriter.flush();
System.out.printf("[%s:%d] req: %s, resp: %s\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort(), request, response);
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// 此处要记得来个关闭操作.
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
TcpEchoServer server = new TcpEchoServer(9090);
server.start();
}
}
TCP客户端
package org.example.tcp.demo2;
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
public class TcpClient {
//服务端IP或域名
private static final String SERVER_HOST = "localhost";
//服务端Socket进程的端口号
private static final int SERVER_PORT = 8888;
public static void main(String[] args) throws IOException {
// 准备要发送的数据：这里调整为键盘输入作为发送的内容
Scanner scanner = new Scanner(System.in);
while(true) {
System.out.println("------------------------------------------------
---");
System.out.println("请输入要展示的目录：");
// 每输入新行（回车），就作为发送的TCP请求报文
String request = scanner.nextLine();
// 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接
Socket socket = new Socket(SERVER_HOST, SERVER_PORT);
// 4.发送TCP数据，是通过socket中的输出流进行发送
OutputStream os = socket.getOutputStream();
// 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF8"));
// 4-1.发送数据：
pw.println(request);
// 4-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
pw.flush();
// 8.接收返回的响应数据：通过socket中的输入流获取
System.out.println("接收到服务端响应：");
InputStream is = socket.getInputStream();
// 为了方便获取字符串内容，可以将以上字节流包装为字符流
BufferedReader br = new BufferedReader(new InputStreamReader(is,
"UTF-8"));
String line;
// 一直读取到流结束：TCP是基于流的数据传输，一定要服务端关闭Socket输出流才表示客
户端接收的IO输入流结束
while ((line = br.readLine()) != null) {
System.out.println(line);
}
// 9.双方关闭连接：客户端关闭socket连接
socket.close();
}
}
}
客户端启动后会等待输入要展示的路径：
---------------------------------------------------
请输入要展示的目录：
在输入想查看的目录路径后，会接收并打印服务端响应的文件列表数据：
---------------------------------------------------
请输入要展示的目录：
/
接收到服务端响应：
1
2
60441b1b8a74be3695ccc0d970693815
8f25103aa249707ee4ab17635142cd0e
---------------------------------------------------
请输入要展示的目录：
此时服务端也会打印接收到的客户端请求数据：
---------------------------------------------------
等待客户端建立TCP连接...
客户端IP：127.0.0.1
客户端端口号：52493
客户端请求的文件列表路径为：E:/TMP/
---------------------------------------------------
等待客户端建立TCP连接...
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoClient {
// 用普通的 socket 即可, 不用 ServerSocket 了
// 此处也不用手动给客户端指定端口号, 让系统自由分配.
private Socket socket = null;
public TcpEchoClient(String serverIP, int serverPort) throws IOException {
// 其实这里是可以给的. 但是这里给了之后, 含义是不同的. ~~
// 这里传入的 ip 和 端口号 的含义表示的不是自己绑定, 而是表示和这个 ip 端口建立连接!!
// 调用这个构造方法, 就会和服务器建立连接 (打电话拨号了)
socket = new Socket(serverIP, serverPort);
}
public void start() {
System.out.println("和服务器连接成功!");
Scanner scanner = new Scanner(System.in);
try (InputStream inputStream = socket.getInputStream()) {
try (OutputStream outputStream = socket.getOutputStream()) {
while (true) {
// 要做的事情, 仍然是四个步骤
// 1. 从控制台读取字符串
System.out.print("-> ");
String request = scanner.next();
// 2. 根据读取的字符串, 构造请求, 把请求发给服务器
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(request);
printWriter.flush(); // 如果不刷新, 可能服务器无法及时看到数据.
// 3. 从服务器读取响应, 并解析
Scanner respScanner = new Scanner(inputStream);
String response = respScanner.next();
// 4. 把结果显示到控制台上.
System.out.printf("req: %s, resp: %s\n", request, response);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9090);
client.start();
}
}
TCP实现一个简单的英译汉的功能
import java.io.IOException;
import java.util.HashMap;
public class TcpDictServer extends TcpThreadPoolEchoServer {
private HashMap<String, String> dict = new HashMap<>();
public TcpDictServer(int port) throws IOException {
super(port);
dict.put("cat", "小猫");
dict.put("dog", "小狗");
dict.put("pig", "小猪");
dict.put("fuck", "卧槽");
}
@Override
public String process(String request) {
return dict.getOrDefault(request, "当前的词无法翻译");
}
public static void main(String[] args) throws IOException {
TcpDictServer server = new TcpDictServer(9090);
server.start();
}
}
目前TCP客户端和服务端实现的功能和UDP差不多，但都存在几个问题：
1、对于服务端来说，处理一次请求并返回响应后，才能再次处理下一次请求和响应，效率是比较低的。这个问题比较好解决：可以使用多线程，每次的请求与响应都在线程中处理。这样多个客户端请求的话，可以在多个线程中并发并行的执行。
2、服务端解析请求，是只读取了一行，而客户端解析响应，是一直读取到流结束。可以想想为什么解
析请求时，没有读取到流结束？
目前的业务，双方都已约定好业务是展示目录下的文件列表，且都只需要一种数据：请求传输的数据代表要展示的目录；响应传输的数据代表文件列表：每一行为一个文件名。
如要提供更多的业务，如文件重命名，文件删除等操作时，就不能了。此时就需要提供更多的字段
来标识。一般我们需要设计更强大的协议。
10、协议
10.1 理解为什么需要协议
以上我们实现的UDP和TCP数据传输，除了UDP和TCP协议外，程序还存在应用层自定义协议，可以想
想分别都是什么样的协议格式。
对于客户端及服务端应用程序来说，请求和响应，需要约定一致的数据格式：
1、客户端发送请求和服务端解析请求要使用相同的数据格式。
2、服务端返回响应和客户端解析响应也要使用相同的数据格式。
3、请求格式和响应格式可以相同，也可以不同。
4、约定相同的数据格式，主要目的是为了让接收端在解析的时候明确如何解析数据中的各个字段。
5、可以使用知名协议（广泛使用的协议格式），如果想自己约定数据格式，就属于自定义协议。
10.2 封装/分用 vs 序列化/反序列化
一般来说，在网络数据传输中，发送端应用程序，发送数据时的数据转换（如java一般就是将对象转换
为某种协议格式），即对发送数据时的数据包装动作来说：
1、如果是使用知名协议，这个动作也称为封装
2、如果是使用小众协议（包括自定义协议），这个动作也称为序列化，一般是将程序中的对象转换为特定的数据格式。
接收端应用程序，接收数据时的数据转换，即对接收数据时的数据解析动作来说：
1、如果是使用知名协议，这个动作也称为分用
2、如果是使用小众协议（包括自定义协议），这个动作也称为反序列化，一般是基于接收数据特定的格式，转换为程序中的对象
10.3 如何设计协议
对于协议来说，重点需要约定好如何解析，一般是根据字段的特点来设计协议：
对于定长的字段：
1、可以基于长度约定，如int字段，约定好4个字节即可。
对于不定长的字段：
1、可以约定字段之间的间隔符，或最后一个字段的结束符，如换行符间隔，\3符号结束等等
2、除了该字段“数据”本身，再加一个长度字段，用来标识该“数据”长度；即总共使用两个字段：
“2.1数据”字段本身，不定长，需要通过“长度”字段来解析；
2.2“长度”字段，标识该“数据”的长度，即用于辅助解析“数据”字段；
10.3.1 TCP/IP五层协议
应用层、传输层、网络层、数据链路层、物理层。
除应用层之外，其他都是操作系统，驱动，硬件，实现好了的，不需要管。
设计应用层协议：
设计一个应用层协议，主要包含两个工作：
1、明确传输信息
2、明确数据的组织格式
当下比较流行的一些数据组织格式的模板
1、xml
2.json
3.protobuffer
前两个可读性好，运行效率不高，后一个可读性不好，运行效率高。
xml
json
传输层
端口号
TCP协议
示例三：多线程+自定义协议
以下我们将示例二的业务做以下扩展：
1、提供多种操作：展示目录下文件列表，文件重命名，删除文件，上传文件，下载文件。
2、在不同的操作中，需要抽象出请求和响应的字段，也即是说，要约定客户端服务端统一的请求协
议，同时也要约定服务端与客户端统一的响应协议。
本示例中的自定义协议
以下为我们TCP请求数据的协议格式，这里简单起见，约定为换行符及结束符：
请求类型
操作的文件或目录路径
数据\3
说明如下：
1、以上总共包含3个字段，前2个字段需要按换行符读取，最后一个字段需要按结束符读取
2、请求类型标识是什么操作：展示目录下文件列表，文件重命名，删除文件，上传文件，下载文件
3、重命名、上传文件操作，需要“数据”字段，其他操作可以置为空字符串。
4、“数据”字段为最后一个字段，使用\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
执行流程
约定好请求和响应的数据格式，也就是应用层协议，大家按照约定好的格式来发送和接收，以下为执行
流程.
代码实现如下：
请求类
先按照约定的请求协议封装请求类：
1、每个字段为一个属性：操作类型，操作路径，数据。
2、完成服务端解析请求封装：按约定的方式读，先按行读取前2个字段，再按结束符读第3个字段。
3、完成客户端发送请求封装：按约定的方式写，前2个字段按行输出，第3个字段以\3结束。
package org.example.tcp.demo3;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
public class Request {
//操作类型：1（展示目录文件列表），2（文件重命名），3（删除文件），4（上传文件），5（下载
文件）
private Integer type;
//操作的目录路径
private String url;
//数据
private String data;
//服务端解析请求时：根据约定好的格式来解析
public static Request serverParse(InputStream is) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF8"));
Request request = new Request();
//前2行分别为操作类型和操作路径
request.type = Integer.parseInt(br.readLine());
request.url = br.readLine();
//使用list保存字符
List<Character> list = new ArrayList<>();
//数据：循环读取
while(true){
//一个字符一个字符的读
char c = (char) br.read();
//一直读取到结束符\3
if(c == '\3')
break;
list.add(c);
}
//拼接数据
StringBuilder sb = new StringBuilder();
for (char c : list){
sb.append(c);
}
request.data = sb.toString();
return request;
}
//客户端发送请求到服务端
public void clientWrite(OutputStream os) throws IOException {
PrintWriter pw = new PrintWriter(os);
pw.println(type);
pw.println(url);
pw.write(data+"\3");
// 4-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
pw.flush();
}
@Override
public String toString() {
return "Request{" +
"type=" + type +
", url='" + url + '\'' +
", data='" + data + '\'' +
'}';
}
public Integer getType() {
return type;
}
public void setType(Integer type) {
this.type = type;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
}
响应类
按照约定的响应协议封装响应类：
1、每个字段为一个属性：响应状态码
2、完成客户端解析响应封装：按约定的方式读，先按行读取第1个字段，再按结束符读第2个字段
3、完成服务端发送响应封装：按约定的方式写，第1个字段按行输出，第2个字段以\3结束。
package org.example.tcp.demo3;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
public class Response {
//响应的状态码，200表示操作成功，404表示没有找到该路径的文件或目录
private int status;
//数据
private String data;
//客户端解析服务端返回的响应数据
public static Response clientParse(InputStream is) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF8"));
Response response = new Response();
response.status = Integer.parseInt(br.readLine());
//使用list保存字符
List<Character> list = new ArrayList<>();
//数据：循环读取
while(true){
//一个字符一个字符的读
char c = (char) br.read();
//一直读取到结束符\3
if(c == '\3')
break;
list.add(c);
}
//拼接数据
StringBuilder sb = new StringBuilder();
for (char c : list){
sb.append(c);
}
response.data = sb.toString();
return response;
}
//服务端返回响应给客户端
public void serverWrite(OutputStream os) throws IOException {
PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
pw.println(status);
pw.write(data+"\3");
// 4-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
pw.flush();
}
@Override
public String toString() {
return "Response{" +
"status=" + status +
", data='" + data + '\'' +
'}';
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
}
TCP服务端
以下完成服务端代码：
1、ServerSocket.accept() 为建立客户端服务端连接的方法，为提高效率，使用多线程。
2、先要解析请求数据，即 Request 已封装好的服务端解析请求，返回 Request 对象。
返回响应数据，需要根据不同的请求字段，做不同的业务处理，并返回对应的响应内容。
2.1 如果操作的url路径再服务端根目录 E:/TMP 下找不到，则返回响应状态码404。
2.2 正常执行完，返回200响应状态码；要注意根据不同操作类型来执行不同的业务。
package org.example.tcp.demo3;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.file.Files;
import java.util.UUID;
public class TcpServer {
//服务器socket要绑定固定的端口
private static final int PORT = 8888;
//本地文件目录要展示的根路径
private static final String BASE_PATH = "E:/TMP";
public static void main(String[] args) throws IOException {
// 1.创建一个服务端ServerSocket，用于收发TCP报文
ServerSocket server = new ServerSocket(PORT);
// 不停的等待客户端连接
while(true) {
// 2.等待客户端连接，注意该方法为阻塞方法
Socket socket = server.accept();
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("------------------------------------
---------------");
System.out.println("客户端建立TCP连接...");
System.out.printf("客户端IP：%s%n",
socket.getInetAddress().getHostAddress());
System.out.printf("客户端端口号：%s%n", socket.getPort());
// 5.接收客户端的数据，需要从客户端Socket中的输入流获取
InputStream is = socket.getInputStream();
// 解析为请求对象
Request request = Request.serverParse(is);
System.out.println("服务端收到请求："+request);
// 6.根据请求处理业务：处理完成返回响应对象
Response response = build(request);
// 7.返回响应给客户端：通过客户端socket中的输出流发送响应数据
OutputStream os = socket.getOutputStream();
// 7-1.返回的响应内容：按照约定格式输出响应对象中的内容
System.out.println("服务端返回响应："+response);
response.serverWrite(os);
// 7-3.双方关闭连接：服务端是关闭客户端socket连接
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
}
}
//根据请求处理业务，返回响应对象
public static Response build(Request request){
Response response = new Response();
response.setStatus(200);
File url = new File(BASE_PATH+request.getUrl());
//该路径的文件或目录不存在
if(!url.exists()){
response.setStatus(404);
response.setData("");
return response;
}
try {
switch (request.getType()){
//1展示目录文件列表
case 1: {
File[] children = url.listFiles();
if(children == null){
response.setData("");
}else{
//拼接要返回的数据：文件列表
StringBuilder sb = new StringBuilder();
for (int i = 0; i < children.length; i++) {
File child = children[i];
//文件路径截取掉服务端本地路径前缀
sb.append(child.getAbsolutePath().substring(BASE_PATH.length())+"\n");
}
response.setData(sb.toString());
}
break;
}
//2文件重命名
case 2: {
url.renameTo(new
File(url.getParent()+File.separator+request.getData()));
break;
}
//3删除文件
case 3: {
url.delete();
break;
}
//上传文件
case 4: {
//上传到请求的操作路径目录下，保存的文件名简单的以随机字符串uuid生成即
可
FileWriter upload = new
FileWriter(url.getAbsolutePath()+File.separator+ UUID.randomUUID());
upload.write(request.getData());
upload.flush();
upload.close();
break;
}
//下载文件
case 5: {
String data = new String(Files.readAllBytes(url.toPath()));
response.setData(data);
break;
}
}
} catch (IOException e) {
e.printStackTrace();
}
return response;
}
}
多线程写法
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TcpThreadEchoServer {
// 但是在 Java socket 中是体现不出来 "监听" 的含义的~~
// 之所以这么叫, 其实是 操作系统原生的 API 里有一个操作叫做 listen
// private ServerSocket listenSocket = null;
private ServerSocket serverSocket = null;
public TcpThreadEchoServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("服务器启动!");
while (true) {
// 由于 TCP 是有连接的, 不能一上来就读数据, 而要先建立连接. (接电话)
// accept 就是在 "接电话", 接电话的前提是, 有人给你打了~~, 如果当前没有客户端尝试建立连接, 此处的 accept 就会阻塞.
// accept 返回了 一个 socket 对象, 称为 clientSocket. 后续和客户端之间的沟通, 都是通过 clientSocket 来完成的.
// 进一步讲, serverSocket 就干了一件事, 接电话~~
Socket clientSocket = serverSocket.accept();
// [改进方法] 在这个地方, 每次 accept 成功, 都创建一个新的线程, 由新线程负责执行这个 processConnection 方法~
Thread t = new Thread(() -> {
processConnection(clientSocket);
});
t.start();
}
}
private void processConnection(Socket clientSocket) {
System.out.printf("[%s:%d] 客户端建立连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
// 接下来来处理请求和响应
// 这里的针对 TCP socket 的读写就和文件读写是一模一样的!!
try (InputStream inputStream = clientSocket.getInputStream()) {
try (OutputStream outputStream = clientSocket.getOutputStream()) {
// 循环的处理每个请求, 分别返回响应
Scanner scanner = new Scanner(inputStream);
while (true) {
// 1. 读取请求
if (!scanner.hasNext()) {
System.out.printf("[%s:%d] 客户端断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
break;
}
// 此处用 Scanner 更方便. 如果不用 Scanner 就用原生的 InputStream 的 read 也是可以的
String request = scanner.next();
// 2. 根据请求, 计算响应
String response = process(request);
// 3. 把这个响应返回给客户端
// 为了方便起见, 可以使用 PrintWriter 把 OutputStream 包裹一下
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(response);
// 刷新缓冲区, 如果没有这个刷新, 可能客户端就不能第一时间看到响应结果.
printWriter.flush();
System.out.printf("[%s:%d] req: %s, resp: %s\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort(), request, response);
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// 此处要记得来个关闭操作.
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
TcpThreadEchoServer server = new TcpThreadEchoServer(9090);
server.start();
}
}
线程池写法
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TcpThreadPoolEchoServer {
// 但是在 Java socket 中是体现不出来 "监听" 的含义的~~
// 之所以这么叫, 其实是 操作系统原生的 API 里有一个操作叫做 listen
// private ServerSocket listenSocket = null;
private ServerSocket serverSocket = null;
public TcpThreadPoolEchoServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("服务器启动!");
ExecutorService pool = Executors.newCachedThreadPool();
while (true) {
// 由于 TCP 是有连接的, 不能一上来就读数据, 而要先建立连接. (接电话)
// accept 就是在 "接电话", 接电话的前提是, 有人给你打了~~, 如果当前没有客户端尝试建立连接, 此处的 accept 就会阻塞.
// accept 返回了 一个 socket 对象, 称为 clientSocket. 后续和客户端之间的沟通, 都是通过 clientSocket 来完成的.
// 进一步讲, serverSocket 就干了一件事, 接电话~~
Socket clientSocket = serverSocket.accept();
// [改进方法] 在这个地方, 每次 accept 成功, 都创建一个新的线程, 由新线程负责执行这个 processConnection 方法~
// 通过线程池来实现
pool.submit(new Runnable() {
@Override
public void run() {
processConnection(clientSocket);
}
});
}
}
private void processConnection(Socket clientSocket) {
System.out.printf("[%s:%d] 客户端建立连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
// 接下来来处理请求和响应
// 这里的针对 TCP socket 的读写就和文件读写是一模一样的!!
try (InputStream inputStream = clientSocket.getInputStream()) {
try (OutputStream outputStream = clientSocket.getOutputStream()) {
// 循环的处理每个请求, 分别返回响应
Scanner scanner = new Scanner(inputStream);
while (true) {
// 1. 读取请求
if (!scanner.hasNext()) {
System.out.printf("[%s:%d] 客户端断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
break;
}
// 此处用 Scanner 更方便. 如果不用 Scanner 就用原生的 InputStream 的 read 也是可以的
String request = scanner.next();
// 2. 根据请求, 计算响应
String response = process(request);
// 3. 把这个响应返回给客户端
// 为了方便起见, 可以使用 PrintWriter 把 OutputStream 包裹一下
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(response);
// 刷新缓冲区, 如果没有这个刷新, 可能客户端就不能第一时间看到响应结果.
printWriter.flush();
System.out.printf("[%s:%d] req: %s, resp: %s\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort(), request, response);
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// 此处要记得来个关闭操作.
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
TcpThreadPoolEchoServer server = new TcpThreadPoolEchoServer(9090);
server.start();
}
}
TCP客户端
package org.example.tcp.demo3;
import java.io.*;
import java.net.Socket;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Scanner;
public class TcpClient {
//服务端IP或域名
private static final String SERVER_HOST = "localhost";
//服务端Socket进程的端口号
private static final int SERVER_PORT = 8888;
public static void main(String[] args) throws IOException {
// 准备要发送的数据：这里调整为键盘输入作为发送的内容
Scanner scanner = new Scanner(System.in);
while(true) {
//根据键盘输入构造一个请求对象，包含操作类型，操作路径，长度和数据
Request request = build(scanner);
// 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接
Socket socket = new Socket(SERVER_HOST, SERVER_PORT);
// 4.发送TCP数据，是通过socket中的输出流进行发送
OutputStream os = socket.getOutputStream();
// 4-1.发送请求数据：按照约定的格式输出请求对象中的内容
System.out.println("客户端发送请求："+request);
request.clientWrite(os);
// 8.接收返回的响应数据：通过socket中的输入流获取
InputStream is = socket.getInputStream();
// 根据约定的格式获取响应数据
Response response = Response.clientParse(is);
System.out.println("客户端收到响应："+response);
// 9.双方关闭连接：客户端关闭socket连接
socket.close();
}
}
//客户端发送请求时，根据键盘输入构造一个请求对象
public static Request build(Scanner scanner) throws IOException {
System.out.println("---------------------------------------------------
");
System.out.println("请输入要操作的类型：1（展示目录文件列表），2（文件重命名），
3（删除文件），4（上传文件），5（下载文件）");
Request request = new Request();
int type = Integer.parseInt(scanner.nextLine());
System.out.println("请输入要操作的路径：");
String url = scanner.nextLine();
String data = "";
//只需要操作类型和操作路径的请求，长度和数据构造为空的
if(type == 2){//重命名操作，需要输入重命名的名称
System.out.println("请输入要重命名的名称：");
data = scanner.nextLine();
}else if(type == 4){//文件上传，需要提供上传的文件路径
System.out.println("请输入要上传的文件路径：");
String upload = scanner.nextLine();
data = new String(Files.readAllBytes(Paths.get(upload)));
}else if(type != 1 && type !=3 && type!=5){
System.out.println("只能输入1-5的数字，请重新输入");
return build(scanner);
}
request.setType(type);
request.setUrl(url);
request.setData(data);
return request;
}
}