[JavaEE -- 传输层中UDP和TCP的api实现原理]
传输层中UDP和TCP的api实现原理
- 1. UDP和TCP协议特点
-
- 1.1 TCP
- 1.2 UDP
- 2. UDP协议中socket api的使用
-
- 2.1 服务器：
- 线程频繁创建,但是不频繁销毁?
- 2.2 客户端
- 2.3 整个流程
- 3. TCP协议中的api使用
-
- 3.1 TCP服务器
- 3.2 TCP客户端
- 3.3 整个流程
1. UDP和TCP协议特点
1.1 TCP
- 有连接：抽象，虚拟的连接（如打电话）
- 可靠传输：尽可能的完成数据传输，虽然无法确保数据到达对方，至少可以知道，当前数据是不是收到了
- 面向字节流：此处的字节流和文件中的字节流完全一致
- 全双工：一个通信可以双向通信。（而半双工只能单向通信）
1.2 UDP
- 无连接：无论是否同意都会发送
- 不可靠传输：不确定数据是否能收到
- 面向数据报：每次传输的基本单位是一个数据报（由一系列的字节构成的）特定结构
- 全双工
2. UDP协议中socket api的使用
操作系统中有一类文件，就叫做socket文件，抽象表示了 网卡 这样的硬件设备。进行网络通信最核心的硬件设备网卡，通过网卡发送数据，就是写socket文件，通过网卡接收数据，就是读socket文件。
核心的类有两个：
-
DatagramSocket
DatagramSocket()，创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机接口（一般用于客户端）。
DatagramSocket(port)，创建一个UDP数据报套接字的Socket，绑定本机指定的端口（一般用于服务器）。
void receive(DatagramPacket p) ：从此套接字接收数据报（如果没有接收数据报，该方法会阻塞等待）。
void send(DatagramPacket p) ：从此套接字发送数据报（不会阻塞等待，直接发送）。 -
DatagramPacket
UDP面向数据报，每次发送数据报的基本单位，就是UDP数据报。表示了一个UDP数据报。
2.1 服务器：
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Socket;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;
public class UdpEchoServer {
//创建DatagramSocket对象
private DatagramSocket socket = null;
public UdpEchoServer(int port) throws SocketException { // 网络编程中常见的异常，通常表示socket创建失败，比如端口号已经被其他进程占用了，就会失败
socket = new DatagramSocket(port);
}
// 服务器启动逻辑
public void start() throws IOException {
System.out.println("服务器启动!");
// 对于服务器来说，需要不停的收到请求，返回响应
while (true) {
// 每次循环，就是处理一个请求-响应过程
// 1. 读取请求并解析
DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);// 通过这个字节数组保存收到的消息正文（应用层数据包）也就是UDP数据报载荷部分
// receive接收从网卡读取到一个UDP数据报，放入requestPacket对象中
socket.receive(requestPacket);
// 读到的字节数组，转成String方便后续逻辑处理
String request = new String(requestPacket.getData(),0,requestPacket.getLength());
// 2. 根据请求计算响应（对于 回显服务器来说，这一步啥也不做）
String response = process(request);
// 3. 把响应返回到客户端
// 构建一个DatagramPacket 作为响应对象
// requestPacket.getSocketAddress() 从requestPacket客户端来的数据报，获得INetAddress对象这个对象就包含了ip和端口号(和服务器通信对端)
//是把请求中的源ip和源端口作为响应的目的IP和目的端口，此时就可以把消息返回给客户端
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 udpEchoServer = new UdpEchoServer(9090);
udpEchoServer.start();
}
}
线程频繁创建,但是不频繁销毁?
即每个客户端处理过程都很长(游戏服务器),如果继续使用线程池/多线程,就会导致当前服务器一下积累了大量的线程.
解决方案:
- 协程
轻量级协程,本质上还是一个线程,用户态可以通过手动调度的方式让这一个线程 "并发"的做多个任务 - IO多路复用
系统内核级别的机制,本质上是让一个线程同时去负责处理多个socket,本质在于这些socket数据并非是同一时刻都需要处理.
理解IO多路复用:
通过三人买东西的方式来理解IO多路复用:
- 单线程(效率比较低):就是一个人先去买饼,等好了之后再去第二个地方买肉夹馍,等买好了之后再去第三个地方买饺子.
- 多线程(效率大大提升了,系统开销也变大了): 三个人分别各自去买一样东西.
- IO多路复用(效率不低,系统开销也不高):一个人先去买饼,点完单不等做好再去下一个地方买肉夹馍,同样点完单不等,再去买饺子
IO多路复用:
基本在于,虽然有多个socket但是同一时刻活跃的socket只是少数,(需要读写数据的socket)大部分socket都在等,使用一个线程来等多个socket.
2.2 客户端
import java.io.IOException;
import java.net.*;
import java.util.Scanner;
public class UdpEchoClient {
private DatagramSocket socket = null;
private String serverIp;
private int serverPort;
// 此处的IP使用的字符串，点分十进制，”192.168.2.100“ 不能直接使用serverIp，要InetAddress.getByName(serverIp)
public UdpEchoClient(String serverIP,int serverPort) throws SocketException {
this.serverIp = serverIP;
this.serverPort = serverPort;
// 客户端一般不要手动指定端口号，系统会自动分配一个空闲的端口号
socket = new DatagramSocket();
}
public void start() throws IOException {
System.out.println("启动客户端");
// 从控制台读取，使用scanner读取字符串，最好使用next而不是nextline（如果读取文件就无所谓），
// 如果使用nextline读取，需要手动输入换行符，enter来控制，由于enter键不仅仅会产生\n，还会产生其他字符，就会导致读取到的内容容易出现问题。
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.print("-> ");
// 1. 从控制台读取要发送的请求数据
if (!scanner.hasNext()) {
break;
}
String request = scanner.next();
// 2. 构造请求并发送 （把string里面的内容作为请求）
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),0,request.getBytes().length
, InetAddress.getByName(serverIp),serverPort);
socket.send(requestPacket);
// 3， 获取服务器响应
DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
socket.receive(responsePacket);
// 4. 把响应显示到控制台上
String response = new String(responsePacket.getData(),0,responsePacket.getLength());
System.out.println(response);
}
}
public static void main(String[] args) throws IOException {
UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090);
client.start();
}
}
2.3 整个流程
- 服务器启动，启动之后立即进入while循环，执行到receive，进入阻塞等待客户端的请求
- 客户端启动之后，阻塞在hasNext等待用户在控制台输入
- 用户在客户端输入之后，客户端就拿到字符串构造出一个（requestPacket）请求，send发送请求，然后创建responsePacket来执行receive接收操作并且等待响应返回。
- 服务器收到请求之后，就会从receive的阻塞中返回，之后就会根据读到的DatagramPacket对象，构造String request，通过process方法构造一个String response，再根据response构建一个DatagramPacket表示响应对象，再通过send来进行发送给客户端。（这个过程中，客户端在阻塞等待）。
- 客户端从receive中返回执行，就能得到服务器返回的响应，并且打印到控制台上，与此同时，服务器进入下一次循环，也要进入到第二次的receive阻塞。等待下一个请求。
3. TCP协议中的api使用
- ServerSocket：这个socket类对应到网卡，但是这个类只能给服务器进行使用
- Socket：对应到网卡，既可以给服务器使用，也可以给客户端使用。
TCP是面向字节流的，传输的基本单位是字节，是有连接的，通过accept来完成连接，accept也是可能会产生阻塞的操作，如果当前客户端还没有连接过来，此时accept就会阻塞。
3.1 TCP服务器
// ServerSocket 这是Socket类对应到网卡，但是这个类只能给服务器使用
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoServer {
private ServerSocket serverSocket = null;
public TcpEchoServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("服务器启动！");
while (true) {
// 通过accept方法来”接听电话“，然后才能进行
Socket clientSocket = serverSocket.accept();
// 和客户端的交互
processConnection(clientSocket);
}
}
// 通过这个方法开处理一次连接，连接建立的过程中就会涉及到多次的请求响应交互
private void processConnection(Socket clientSocket) {
System.out.printf("[%s:%d] 客户端上线！\n",clientSocket.getInetAddress(),clientSocket.getPort());
// 循环的读取客户端的请求并返回响应
// 从网卡读/写数据，tcp是面向字节流和文件中的字节流完全一致
try (InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream()) {
while (true) {
Scanner scanner = new Scanner(inputStream);
if (!scanner.hasNext()) {
// 读取完毕，客户端断开连接，就会产生读取完毕
System.out.printf("[%s:%d] 客户端下线！\n",clientSocket.getInetAddress(),
clientSocket.getPort());
break;
}
// 1. 读取请求并解析,这里注意隐的约定，next读的时候要读到空白符才会结束
// 因此就要求客户端发来的请求必须带有空白符结尾，比如 \n 或空格
String request = scanner.next();
// 2. 根据请求计算响应
String response = process(request);
// 3. 把响应返回给客户端
// 通过这种方式可以写回，但是这种方式不方便给返回的响应添加 \n
//outputStream.write(response.getBytes(),0,response.getBytes().length);
// 也可以把outputStream 套上一层，完成更方便的写入
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(response);
// PrintWriter 内置的缓冲区需要冲刷（刷新）
// 冲刷缓冲区
printWriter.flush();
System.out.printf("[%s:%d] req:%s,resp: %s\n",clientSocket.getInetAddress(),
clientSocket.getPort(),request,response);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
TcpEchoServer tcpEchoServer = new TcpEchoServer(9090);
tcpEchoServer.start();
}
}
3.2 TCP客户端
// Socket 对应到网卡，既可以给服务器使用，又可以给客户端使用
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 TcpEchoClient {
private Socket socket = null;
public TcpEchoClient(String serverIP,int serverPort) throws IOException {
// 此处可以把这里的ip和port直接传给socket对象
// 由于tcp是有连接的，因此socket里面就会保存好这俩信息，因此此处TcpEchoClient类就不必保存
socket = new Socket(serverIP,serverPort);
}
public void start() {
System.out.println("客户端启动！\n");
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
Scanner scannerConsole = new Scanner(System.in);
Scanner scannerNetwork = new Scanner(inputStream);
PrintWriter writer = new PrintWriter(outputStream);
while (true) {
// 1. 从控制台读取输入的字符串
System.out.print("-> ");
if (!scannerConsole.hasNext()) {
// 没有下一个
break;
}
// 有下一个接着读取
String request = scannerConsole.next();
// 2. 把请求发给服务器 使用println 来发送的请求末尾带有\n
// 这里是和服务器的scanner.next 呼应的
writer.println(request);
// 通过flush 主动刷新缓冲区，确保数据真的发出去了
writer.flush();
// 3.从服务器读取响应
String response = scannerNetwork.next();
// 4. 把响应显示出来
System.out.println(response);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) throws IOException {
TcpEchoClient client = new TcpEchoClient("127.0.0.1",9090);
client.start();
}
}
3.3 整个流程
- 服务器启动，阻塞在accept，等待客户端连接
- 客户端启动，new Socket(ServerIP,ServerPort)操作会触发和服务器之间的建立连接的操作，此时服务器就会从accept中返回
- 服务器从accept返回，进入到processConnection方法，执行到hasNext这里，产生阻塞，此时虽然连接建立了，但是客户端还没有发送任何的请求，hasNext阻塞等待请求到达。
- 客户端继续执行到hasNext，等待用户向控制台写入内容。
- 用户输入之后，此时hasNext就返回了，继续执行这里的发送请求的逻辑，这里就会把请求真的发出去，同时客户端等待服务器的响应返回，next也会产生阻塞。
- 服务器从hasNext返回读取到请求内容进行处理，读取到请求，构造出响应，把响应写回到客户端。服务器结束这次循环，继续阻塞在hasNext等待下一个请求。
- 客户端读取响应，并且显示出来。结束这次循环，进行下一次循环，继续阻塞在hasNext等待用户输入第二个数据。