网络编程
网络编程基础
什么是网络编程
网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）。
当然，我们只要满足进程不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据，也属于网络编程。
特殊的，对于开发来说，在条件有限的情况下，一般也都是在一个主机中运行多个进程来完成网络编程。
但是，我们一定要明确，我们的目的是提供网络上不同主机，基于网络来传输数据资源：
进程A：编程来获取网络资源
进程B：编程来提供网络资源
网络编程中的基本概念
发送端和接收端
在一次网络数据传输时：
发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端两端，也简称为收发端。
注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念。
请求和响应
一般来说，获取一个网络资源，涉及到两次网络数据传输：
第一次：请求数据的发送
第二次：响应数据的发送。
好比在快餐店点一份炒饭：
先要发起请求：点一份炒饭，再有快餐店提供的对应响应：提供一份炒饭
客户端和服务端
服务端：在常见的网络数据传输场景下，把提供服务的一方进程，称为服务端，可以提供对外服务。
客户端：获取服务的一方进程，称为客户端。
对于服务来说，一般是提供：
- 客户端获取服务资源
- 客户端保存资源在服务端
好比在银行办事：
- 银行提供存款服务：用户（客户端）保存资源（现金）在银行（服务端）
- 银行提供取款服务：用户（客户端）获取服务端资源（银行替用户保管的现金）
常见的客户端服务端模型
最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序：
1.客户端先发送请求到服务端
2.服务端根据请求数据，执行相应的业务处理
3.服务端返回响应：发送业务处理结果
4.客户端根据响应数据，展示处理结果（展示获取的资源，或提示保存资源的处理结果）
Socket套接字
概念
Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。
分类
Socket套接字主要针对传输层协议划分为如下三类：
流套接字：使用传输层TCP协议
TCP，即Transmission Control Protocol（传输控制协议），传输层协议。
以下为TCP的特点（细节后续再学习）：
- 有连接
- 可靠传输
- 面向字节流
- 有接收缓冲区，也有发送缓冲区
- 大小不限
对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收。
数据报套接字：使用传输层UDP协议
UDP，即User Datagram Protocol（用户数据报协议），传输层协议。
以下为UDP的特点（细节后续再学习）
- 无连接
- 不可靠传输
- 面向数据报
- 有接收缓冲区，无发送缓冲区
- 大小受限：一次最多传输64k
对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100个字节，必须一次发送，接收也必须一次接收100个字节，而不能分100次，每次接收1个字节。
原始套接字
原始套接字用于自定义传输层协议，用于读写内核没有处理的IP协议数据。
我们不学习原始套接字，简单了解即可。
Java数据报套接字通信模型
对于UDP协议来说，具有无连接，面向数据报的特征，即每次都是没有建立连接，并且一次发送全部数据报，一次接收全部的数据报。
java中使用UDP协议通信，主要基于 DatagramSocket类来创建数据报套接字，并使用DatagramPacket作为发送或接收的UDP数据报。对于一次发送及接收UDP数据报的流程如下：
以上只是一次发送端的UDP数据报发送，及接收端的数据报接收，并没有返回的数据。也就是只有请求，没有响应。对于一个服务端来说，重要的是提供多个客户端的请求处理及响应，流程如下：
Java流套接字通信模型
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的绑定端口，换为其他没有使用的端口。
UDP数据报套接字编程
DatagramSocket API
DatagramSocket是UDP Socket，用于发送和接收UDP数据报。
DatagramSocket构造方法：
DatagramSocket方法：
DatagramPacket API
DatagramPacket是UDP Socket发送和接收的数据报。
DatagramPacket构造方法：
DatagramPacket方法：
构造UDP发送的数据报时，需要传入 SocketAddress，该对象可以使用 InetSocketAddress来创建。
InetSocketAddress API
InetSocketAddress（ SocketAddress的子类）构造方法
示例一：一发一收（无响应）
以下为一个客户端一次数据发送，和服务端多次数据接收（一次发送一次接收，可以接收多次），即只有客户端请求，但没有服务端响应的示例：
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数据报。
UDP客户端
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);
}
}
客户端启动后会发送一个"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<M，则会发生数据部分丢失（可以自己尝试，把接收的字节数组长度指定为比发送的字节
数组长度更短）。
要解决以上问题，就需要发送端和接收端双方约定好一致的协议，如规定好结束的标识或整个数据的长度。
示例二：请求响应
示例一只是客户端请求和服务端接收，并没有包含服务端的返回响应。以下是对应请求和响应的改造：
构造一个展示服务端本地某个目录（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数据报...
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数据报...
TCP流套接字编程
和刚才UDP类似.实现一个简单的英译汉的功能
ServerSocket API
ServerSocket是创建TCP服务端Socket的API。
ServerSocket构造方法：
ServerSocket方法：
Socket API
Socket是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
Socket构造方法
Socket方法：
TCP中的长短连接
TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：
短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数
据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。
对比以上长短连接，两者区别如下：
- 建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
- 主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。
- 两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。
扩展了解：
基于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, "UTF-
8"));
// 7-1.返回的响应内容：每个文件及目录名称为一行
if(children != null){
for (File child : children) {
pw.println(child.getName());
}
}
// 7-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
pw.flush();
// 7-3.双方关闭连接：服务端是关闭客户端socket连接
socket.close();
}
}
}
以上服务端运行结果和示例一是一样的：
---------------------------------------------------
等待客户端建立TCP连接...
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, "UTF-
8"));
// 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连接...
目前TCP客户端和服务端实现的功能和UDP差不多，但都存在几个问题：
- 对于服务端来说，处理一次请求并返回响应后，才能再次处理下一次请求和响应，效率是比较低的。这个问题比较好解决：可以使用多线程，每次的请求与响应都在线程中处理。这样多个客户端请求的话，可以在多个线程中并发并行的执行。
- 服务端解析请求，是只读取了一行，而客户端解析响应，是一直读取到流结束。可以想想为什么解析请求时，没有读取到流结束？
目前的业务，双方都已约定好业务是展示目录下的文件列表，且都只需要一种数据：请求传输的数据代表要展示的目录；响应传输的数据代表文件列表：每一行为一个文件名。
如要提供更多的业务，如文件重命名，文件删除等操作时，就不能了。此时就需要提供更多的字段来标识。一般我们需要设计更强大的协议。
再谈协议
回顾并理解为什么需要协议
以上我们实现的UDP和TCP数据传输，除了UDP和TCP协议外，程序还存在应用层自定义协议，可以想想分别都是什么样的协议格式。
对于客户端及服务端应用程序来说，请求和响应，需要约定一致的数据格式：
- 客户端发送请求和服务端解析请求要使用相同的数据格式。
- 服务端返回响应和客户端解析响应也要使用相同的数据格式。
- 请求格式和响应格式可以相同，也可以不同。
- 约定相同的数据格式，主要目的是为了让接收端在解析的时候明确如何解析数据中的各个字段。
- 可以使用知名协议（广泛使用的协议格式），如果想自己约定数据格式，就属于自定义协议。
封装/分用 vs序列化/反序列化
一般来说，在网络数据传输中，发送端应用程序，发送数据时的数据转换（如java一般就是将对象转换为某种协议格式），即对发送数据时的数据包装动作来说：
-
如果是使用知名协议，这个动作也称为封装
-
如果是使用小众协议（包括自定义协议），这个动作也称为序列化，一般是将程序中的对象转换为特定的数据格式。
接收端应用程序，接收数据时的数据转换，即对接收数据时的数据解析动作来说： -
如果是使用知名协议，这个动作也称为分用
-
如果是使用小众协议（包括自定义协议），这个动作也称为反序列化，一般是基于接收数据特定的格式，转换为程序中的对象
如何设计协议
对于协议来说，重点需要约定好如何解析，一般是根据字段的特点来设计协议：
对于定长的字段：
- 可以基于长度约定，如int字段，约定好4个字节即可
对于不定长的字段：
- 可以约定字段之间的间隔符，或最后一个字段的结束符，如换行符间隔，\3符号结束等等
- 除了该字段“数据”本身，再加一个长度字段，用来标识该“数据”长度；即总共使用两个字段：
- “数据”字段本身，不定长，需要通过“长度”字段来解析；
- “长度”字段，标识该“数据”的长度，即用于辅助解析“数据”字段；
示例三：多线程+自定义协议
详情见讲义。
示例代码
UdpEchoServer.java
package network;
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();
}
}
UdpEchoClient.java
package network;
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();
}
}
UdpDictServer.java
package network;
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();
}
}
TcpEchoServer.java
package network;
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();
}
}
TcpEchoClient.java
package network;
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();
}
}
TcpDictServer.java
package network;
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();
}
}
TcpThreadEchoServer.java
package network;
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();
}
}
TcpThreadPoolEchoServer.java
package network;
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();
}
}