网络编程套接字
目录
网络编程基础
为什么需要网络编程？
什么是网络编程
网络编程中的基本概念
发送端和接收端
请求和响应
客户端和服务端
常见的客户端服务端模型
Socket套接字
概念
分类
Java数据报套接字通信模型
Java流套接字通信模型
Socket编程注意事项
UDP数据报套接字编程
DatagramSocket API
DatagramPacket API
InetSocketAddress API
示例：一发一收（无响应）
UDP服务端
UDP客户端
TCP流套接字编程
ServerSocket API
Socket API
TCP中的长短连接
示例：
TCP服务端
TCP客户端
再谈协议
回顾并理解为什么需要协议
封装/分用 vs 序列化/反序列化
如何设计协议
网络编程基础
为什么需要网络编程？
现在网络普及程序越来越多，网络上保存着我们日常生活中需要的各种资源，使用程序通过网络来获取这些资源的过程就需要网络编程来实现。
什么是网络编程
网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）。
当然，我们只要满足进程不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据， 也属于网络编程。
特殊的，对于开发来说，在条件有限的情况下，一般也都是在一个主机中运行多个进程来完成网络编 程。
但是，我们一定要明确，我们的目的是提供网络上不同主机，基于网络来传输数据资源：
- 进程A：编程来获取网络资源
- 进程B：编程来提供网络资源
网络编程中的基本概念
发送端和接收端
在一次网络数据传输时：
发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端两端，也简称为收发端。
注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念。
请求和响应
一般来说，获取一个网络资源，涉及到两次网络数据传输：
- 第一次：请求数据的发送
- 第二次：响应数据的发送。
好比在快餐店点一份炒饭：
先要发起请求：点一份炒饭，再有快餐店提供的对应响应：提供一份炒饭
客户端和服务端
服务端：在常见的网络数据传输场景下，把提供服务的一方进程，称为服务端，可以提供对外服务。
客户端：获取服务的一方进程，称为客户端。
对于服务来说，一般是提供：
- 客户端获取服务资源
- 客户端保存资源在服务端
好比在银行办事：
- 银行提供存款服务：用户（客户端）保存资源（现金）在银行（服务端）
- 银行提供取款服务：用户（客户端）获取服务端资源（银行替用户保管的现金）
常见的客户端服务端模型
最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序：
- 客户端先发送请求到服务端
- 服务端根据请求数据，执行相应的业务处理
- 服务端返回响应：发送业务处理结果
- 客户端根据响应数据，展示处理结果（展示获取的资源，或提示保存资源的处理结果）
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数据报的流程如下：
Java流套接字通信模型
Socket编程注意事项
- 客户端和服务端：开发时，经常是基于一个主机开启两个进程作为客户端和服务端，但真实的场景，一般都是不同主机。
- 注意目的IP和目的端口号，标识了一次数据传输时要发送数据的终点主机和进程
- Socket编程我们是使用流套接字和数据报套接字，基于传输层的TCP或UDP协议，但应用层协议，也需要考虑，这块我们在后续来说明如何设计应用层协议。
- 关于端口被占用的问题
如果一个进程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()
|
创建一个 UDP 数据报套接字的 Socket ，绑定到本机任意一个随机端口（一般用于客户端）
|
|
DatagramSocket(int
port)
|
创建一个 UDP 数据报套接字的 Socket ，绑定到本机指定的端口（一般用于服务端）
|
DatagramSocket 方法：
|
方法签名
|
方法说明
|
|
void
receive(DatagramPacket p)
|
从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待）
|
|
void send(DatagramPacket p)
|
从此套接字发送数据报包（不会阻塞等待，直接发送）
|
|
void close()
|
关闭此数据报套接字
|
DatagramPacket API
DatagramPacket是UDP Socket发送和接收的数据报。
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 来创 建。
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", newString(packet.getData()));
}
}
}运行后，服务端就启动了，控制台输出如下：
可以看出，此时代码是阻塞等待在 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数据报（假设发送的数据字节数组长度为M），在接收到以后（假设接收的数据字节数组长度为N）：
- 如果N>M，则接收的byte[]字节数组中会有很多初始化byte[]的初始值0，转换为字符串就是空白 字符；
- 如果N
要解决以上问题，就需要发送端和接收端双方约定好一致的协议，如规定好结束的标识或整个数据的长度。
TCP流套接字编程
ServerSocket API
ServerSocket 是创建TCP服务端Socket的API。
ServerSocket 构造方法：
|
方法签名
|
方法说明
|
|
ServerSocket(int port)
|
创建一个服务端流套接字 Socket ，并绑定到指定端口
|
ServerSocket 方法：
| 方法签名 | 方法说明 |
|
Socket
accept()
|
开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端 Socket对象，并基于该Socket 建立与客户端的连接，否则阻塞等待
|
|
void
close()
|
关闭此套接字
|
Socket API
Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端 Socket。
不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据 的。
Socket 构造方法：
|
方法签名
|
方法说明
|
|
Socket(String host, int port)
|
创建一个客户端流套接字 Socket ，并与对应 IP 的主机上，对应端口的 进程建立连接
|
Socket 方法：
|
方法签名
|
方法说明 |
|
InetAddress getInetAddress()
|
返回套接字所连接的地址
|
|
InputStream getInputStream()
|
返回此套接字的输入流
|
|
OutputStream getOutputStream()
|
返回此套接字的输出流
|
TCP中的长短连接
TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：
短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。
对比以上长短连接，两者区别如下：
- 建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
- 主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。
- 两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。
扩展了解：
基于BIO（同步阻塞IO）的长连接会一直占用系统资源。对于并发要求很高的服务端系统来说，这样的 消耗是不能承受的。
由于每个连接都需要不停的阻塞等待接收数据，所以每个连接都会在一个线程中运行。
一次阻塞等待对应着一次请求、响应，不停处理也就是长连接的特性：一直不关闭连接，不停的 处理请求。
实际应用时，服务端一般是基于NIO（即同步非阻塞IO）来实现长连接，性能可以极大的提升。
示例：
TCP服务端
package org.example.network.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.text.MessageFormat;
import java.util.Scanner;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author: ZQ
* @date: 2023/5/28 13:07
* @description: TCP服务端
*/
public class TCPEchoServer {
// 声明一个用于服务端的Socket对象
private ServerSocket server;
/**
* 通过指定端口号实例化服务
*
* @param port 端口号
* @throws IOException
*/
public TCPEchoServer(int port) throws IOException {
if (port < 1025 || port > 65535) {
throw new RuntimeException("端口号要在 1025 ~ 65535之间.");
}
// 实例化ServerSocket并指定端口号
this.server = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("服务器启动成功...");
// 创建一个线程池
ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 10, 1, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(10));
// 循环接收客户端的连接
while (true) {
Socket clientSocket = server.accept();
// 每接收到一个新连接请求，就创建一个新的子线程
// Thread thread = new Thread(() -> {
// // 处理Socket中的数据
// try {
// processConnections(clientSocket);
// } catch (IOException e) {
// e.printStackTrace();
// }
// });
// // 启动线程
// thread.start();
// 提交任务到线程池中
poolExecutor.submit(() -> {
try {
processConnections(clientSocket);
} catch (IOException e) {
e.printStackTrace();
}
});
}
}
// 处理数据
private void processConnections(Socket clientSocket) throws IOException {
// 打印日志
String clientInfo = MessageFormat.format("[{0}:{1}] 客户端已上线", clientSocket.getInetAddress(),
clientSocket.getPort());
System.out.println(clientInfo);
// 处理数据之前要获取一下输入输出流
try (InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream()) {
// 循环处理用户的请求
while (true) {
// 通过Scanner读取用户请求中的数据
Scanner requestScanner = new Scanner(inputStream);
if (!requestScanner.hasNextLine()) {
// 日志
clientInfo = MessageFormat.format("[{0}:{1}] 客户端已下线.", clientSocket.getInetAddress(),
clientSocket.getPort());
System.out.println(clientInfo);
break;
}
// 获取真实的用户请求数据
String request = requestScanner.nextLine();
// 根据请求计算响应
String response = process(request);
// 把响应写回客户端
PrintWriter printWriter = new PrintWriter(outputStream);
// 写入输出流
printWriter.println(response);
// 强制刷新缓冲区
printWriter.flush();
// 打印日志
clientInfo = MessageFormat.format("[{0}:{1}], request: {2}, response: {3}",
clientSocket.getInetAddress(), clientSocket.getPort(), request, response);
System.out.println(clientInfo);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
clientSocket.close();
}
}
private String process(String request) {
System.out.println("收到新消息：" + request);
Scanner scanner = new Scanner(System.in);
String response = scanner.nextLine();
return response;
}
public static void main(String[] args) throws IOException {
TCPEchoServer server = new TCPEchoServer(9999);
server.start();
}
}
TCP客户端
package org.example.network.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;
/**
* @author: ZQ
* @date: 2023/5/28 13:05
* @description: TCP客户端
*/
public class TCPEchoClient {
// 定义一个用于客户端的Socket对象
private Socket clientSocket;
/**
* 初始化客户端的Socket
*
* @param serverIp 服务器IP地址
* @param serverPort 服务器的端口号
* @throws IOException
*/
public TCPEchoClient (String serverIp, int serverPort) throws IOException {
this.clientSocket = new Socket(serverIp, serverPort);
}
public void start () throws IOException {
System.out.println("客户端已启动...");
// 获取Socket中的输入输出流
try (InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream()) {
// 循环处理用户的输入
while (true) {
System.out.println("->");
// 接收用户的输入内容
Scanner requestScanner = new Scanner(System.in);
String request = requestScanner.nextLine();
// 发送用户的请求
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(request);
// 强制刷新缓冲区
printWriter.flush();
// 接收服务器的响应
Scanner responseScanner = new Scanner(inputStream);
// 获取响应数据
String response = responseScanner.nextLine();
// 打印响应内容
System.out.println("接收到服务器的响应：" + response);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
clientSocket.close();
}
}
public static void main(String[] args) throws IOException {
TCPEchoClient client = new TCPEchoClient("127.0.0.1", 9999);
client.start();
}
}
再谈协议
回顾并理解为什么需要协议
以上我们实现的UDP和TCP数据传输，除了UDP和TCP协议外，程序还存在应用层自定义协议，可以想 想分别都是什么样的协议格式。
对于客户端及服务端应用程序来说，请求和响应，需要约定一致的数据格式：
- 格式客户端发送请求和服务端解析请求要使用相同的数据。
- 服务端返回响应和客户端解析响应也要使用相同的数据格式。
- 请求格式和响应格式可以相同，也可以不同。
- 约定相同的数据格式，主要目的是为了让接收端在解析的时候明确如何解析数据中的各个字段。
- 可以使用知名协议（广泛使用的协议格式），如果想自己约定数据格式，就属于自定义协议。
封装/分用 vs 序列化/反序列化
一般来说，在网络数据传输中，发送端应用程序，发送数据时的数据转换（如java一般就是将对象转换 为某种协议格式），即对发送数据时的数据包装动作来说：
如果是使用知名协议，这个动作也称为封装
如果是使用小众协议（包括自定义协议），这个动作也称为序列化，一般是将程序中的对象转换为 特定的数据格式。
接收端应用程序，接收数据时的数据转换，即对接收数据时的数据解析动作来说：
如果是使用知名协议，这个动作也称为分用
如果是使用小众协议（包括自定义协议），这个动作也称为反序列化，一般是基于接收数据特定的 格式，转换为程序中的对象
如何设计协议
对于协议来说，重点需要约定好如何解析，一般是根据字段的特点来设计协议：
对于定长的字段：
- 可以基于长度约定，如int字段，约定好4个字节即可
对于不定长的字段：
可以约定字段之间的间隔符，或最后一个字段的结束符，如换行符间隔，\3符号结束等等
除了该字段“数据”本身，再加一个长度字段，用来标识该“数据”长度；即总共使用两个字段：
- “数据”字段本身，不定长，需要通过“长度”字段来解析
- “长度”字段，标识该“数据”的长度，即用于辅助解析“数据”字段；