【网络】UDP和TCP之间的差别和回显服务器

文章目录

UDP 和 TCP 之间的差别
- 有连接/无连接
- 可靠传输/不可靠传输
- 面向字节流/面向数据报
- 全双工/半双工
UDP/TCP API 的使用
- UDP API
- - DatagramSocket
  - - 构造方法
    - 方法
  - DatagramPacket
  - - 构造方法
    - 方法
  - 回显服务器（Echo Server）
  - - 1. 接收请求
    - 2. 根据请求计算响应
    - 3. 将响应写回客户端
    - 完整代码

学习多线程，打破了以往对于程序的认知
学习网络编程，将会再次打破对于程序的认知

套接字：Socket 单词
操作系统给应用程序（传输层给应用层）提供的 API，起了个名字，就叫 Socket API

Socket 本身是“插槽”的意思

电脑的主板，插着各种其他的硬件

接下来学习的就是操作系统提供的 Socket API（Java 版本的）

UDP 和 TCP 之间的差别

socket API 提供了两组不同的 API，UDP 有一套，TCP 也有一套

TCP 有连接，可靠传输，面向字节流，全双工
UDP 无连接，不可靠传输，面向数据报，全双工

有连接/无连接

此处谈到的连接，是“抽象”的连接

通信双方，如果保存了通信对端的信息，就相当与是“有连接”；如果不保存对端的信息，就是“无连接”
连接：通信双方 A 保存了 B 的信息（IP 和端口号），B 也保存了 A 的信息
如果通信双方，各自把对方的信息删除掉，此时就相当与“断开了连接”

举个栗子：

将来你和你的另一半去领证，结婚证上就会写上两个人的名字，贴上照片。一式两份，你保存一份，你的另一半保存一份
你的本上保留了 ta 的信息，你翻开本就能看到另一个人是 ta
ta 的本上保留了你的信息，ta 翻开本就能看到另一个人是你
此时你们俩就相当于建立了“抽象的/逻辑上的连接”

可靠传输/不可靠传输

此处谈到的“可靠”，不是指 100% 能到达对方，而是 “尽可能”到达对方

因为网络环境非常复杂，存在很多的不确定因素（你再厉害的技术，也抵不过挖掘机一铲子）
相对来说，不可靠就是完全不考虑数据是否能到达对方

TCP 内置了一些机制，能够保证可靠传输

感知到对方是不是收到了
重传机制，在对方没收到的时候进行重试

UDP 则没有这种可靠性机制，完全不管发出去的数据是否顺利到达对方

直观感觉，可靠比不可靠传输更好？

但可靠传输要付出代价，TCP 协议设计就要比 UDP 复杂很多，也会损失一些传输数据的效率

面向字节流/面向数据报

TCP 是面向字节流的，TCP 的传输过程就和文件流/水流是一样的特点

从文件读写 100 个字节
1. 一次读写 100 字节
2. 两次，一次读写 50 字节
3. 十次，一次读写 10 字节
4. …
TCP 读写，和文件读写是一摸一样的

UDP 是面向数据报的，传输数据的基本单位不是字节，而是“UDP 数据报”

一次发送/接收，必须是完整的 UDP 数据报

这些差别，会直接影响到代码的写法

全双工/半双工

全双工：一个通信链路，可以发送数据，也可以接收数据（双向通信）
半双工：一个通信链路，只能发送/只能接收（单向通信）

有一根网线，怎么进行双向通信呢？

全双工这个事情，物理层面上，并非是只有一根线在连接
一根网线里，有 8 根铜线，分成 4 4 一组（四根就可以正常工作，另外四根是防止意外情况发生的铜线备份）
主要的四根线中，两根线用来负责发送，两根用来接收

UDP/TCP API 的使用

UDP API

API 就是一组函数/一组类

DatagramSocket

网卡的遥控器

代表一个 Socket 对象

属于操作系统的概念，Socket 就可以认为是操作系统中，广义的文件里面的一种文件类型
- 这样的文件，就是网卡/控制台/键盘/显卡…这种硬件设备抽象的表示形式
  - 所以 Socket 也具有一些文件的特性，操作文件需要先打开、再读写、再关闭。Socket 也是这样
  - 包括创建一个 Socket 对象，也会占用一个文件描述符表里面的资源
- 在这里 Socket 对象，就是网卡的代言人
  - 因为我们通过代码直接操作网卡是不好操作的
  - 网卡有很多种型号，之间提供的 API 都会有差别
  - 于是操作系统就把网卡概念封装成 Socket，应用程序员就不需要关注硬件的差异和细节，直接统一操作 Socket 对象就能间接的操作网卡了
  - Socket 就像万能遥控器一样

构造方法

	方法签名	方法说明
	DatagramSocket ()	创建⼀个 `UDP` 数据报套接字的 `Socket`，绑定到本机任意⼀个随机端⼝（⼀般⽤于客⼾端）
	DatagramSocket (int port)	创建⼀个 `UDP` 数据报套接字的 `Socket`，绑定到本机指定的端⼝（需要指定端口号，⼀般⽤于服务端）

方法

	方法签名	方法说明
	void receive (DatagramPacket p)	从此套接字接收数据报（如果没有接收到数据报，该⽅法会阻塞等待）
	void send (DatagramPacket p)	从此套接字发送数据报包（不会阻塞等待，直接发送）
	void close ()	关闭此数据报套接字

DatagramPacket

UDP 传输数据的基本单位

代表一个 UDP 数据报

构造方法

	方法签名	方法说明
	DatagramPacket(byte[] buf, int length)	构造⼀个 `DatagramPacket` 以⽤来接收数据报，接收的数据保存在字节数组（第⼀个参数 `buf`）中，接收指定⻓度（第⼆个参数 `length`）
	DatagramPacket(byte[] buf, int offset, int length, SocketAddress address)	构造⼀个 `DatagramPacket` 以⽤来发送数据报，发送的数据为字节数组（第⼀个参数 `buf`）中，从 `0` 到指定⻓度（第⼆个参数 `length`）。`address` 指定⽬的主机的 `IP` 和端⼝号

方法

	方法签名	方法说明
	InetAddress getAddress()	从接收的数据报中，获取发送端主机 `IP` 地址；或从发送的数据报中，获取接收端主机 `IP` 地址
	int getPort()	从接收的数据报中，获取发送端主机的端⼝号；或从发送的数据报中，获取接收端主机端口号
	byte[] getData()	获取数据报中的数据

回显服务器（Echo Server）

最简单的客户端服务器程序，不涉及到业务流程，只是对与 API 的用法做演示

客户端发送什么样的请求，服务器就返回什么样的响应，没有任何业务逻辑，没有进行任何计算或者处理

网络编程必须要使用网卡，就需要用到 Socket 对象
- 创建一个 DatagramSocket 对象，之后在基于这个对象进行操作

import java.net.DatagramSocket;  
import java.net.SocketException;  
  
public class UdpEchoServer {  
    private DatagramSocket socket = null;  
  
    public UdpEchoServer(int port) throws SocketException {  
    //SocketException 异常是 IOException 的子类
        socket = new DatagramSocket(port);  
    }
}

对于服务器这一端来说，需要在 socket 对象创建的时候，就指定一个端口号 port，作为构造方法的参数
后续服务器开始运行之后，操作系统就会把端口号和该进程关联起来
端口号的作用就是来区分进程的，一台主机上可能有很多个进程很多个程序，都要去操作网络。当我们收到数据的时候，哪个进程来处理，就需要通过端口号去区分
- 所以就需要在程序一启动的时候，就把这个程序关联哪个端口指明清楚

在调用这个构造方法的过程中，JVM 就会调用系统的 Socket API，完成“端口号-进程”之间的关联动作
- 这样的操作也叫“绑定端口号”（系统原生 API 名字就叫 bind）
- 绑定好了端口号之后，就明确了端口号和进程之间的关联关系

对于一个系统来说，同一时刻，一个端口号只能被一个进程绑定；但是一个进程可以绑定多个端口号（通过创建多个 Socket 对象来完成）
- 因为端口号是用来区分进程，收到数据之后，明确说这个数据要给谁，如果一个端口号对应到多个进程，那么就难以起到区分的效果
- 如果有多个进程，尝试绑定一个端口号，只有一个能绑定成功，后来的都会绑定失败

1. 接收请求

通过 start 来启动服务器的核心流程
对于服务器来说，主要的工作，就是不停地处理客户端发来的请求，因为客户端什么时候会发来请求是未知的，所以要时刻待命

public void start() {  
    System.out.println("服务器启动！");  
    //通过一个死循环来不停地处理请求  
    while(true) {  
    	//1. 读取客户端的请求并解析
    	socket.receive();  
    }
}

对 7*24 小时工作的服务器来说，服务器里面有死循环是很正常的，不是说死循环就是代码 bug

读取客户端的请求并解析
- receive 是从网卡上读取数据，但是调用 receive 的时候，网卡上不一定就有数据
- 当调用 start 方法之后程序启动，就立刻调用了 receive，一调用 receive，就会立刻从网卡中读取数据，但这个时候客户端可能还没来，网卡中还没有数据
- 如果网卡上收到数据了，receive 立刻返回，获取收到的数据；如果没有收到数据，receive 就会阻塞等待，直到真正收到数据为止
- 此处 receive 也是通过“输出型参数”获取到网卡上收到的数据的

receive 的参数是 DatagramPacket
- 我们就需要构造一个空的 DatagramPacket 对象，将其作为参数传递给 receive

public void start() throws IOException {  
    System.out.println("服务器启动！");  
    //通过一个死循环来不停地处理请求  
    while(true) {  
        //1. 读取客户端的请求并解析  
        DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);  
        socket.receive(requestPacket);  
    }
}

DatagramPacket 自身需要存储数据，但是数据的空间具体多大，需要外部来定义，自身不负责
需要指定 requestPacket 所需要存储数据/持有数据的基数
- 指定一个字节数组，和其长度
- 大小没什么讲究，只要能确保能够存储下你通讯的一个数据包即可
收到的请求数据是通过二进制 byte[] 的形式来体现的，而我们后续要将其进行处理，最好将它转成字符串才好处理

public void start() throws IOException {  
    System.out.println("服务器启动！");  
    //通过一个死循环来不停地处理请求  
    while(true) {  
        //1. 读取客户端的请求并解析  
        DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);  
        socket.receive(requestPacket);  
        
    	//将收到的二进制 byte[] 数据转换成字符串  
        String request = new String(requestPacket.getData(),0,requestPacket.getLength());  
    }
}

构造 String 可以基于字节数组构造，也可以基于字符数组进行构造
- 此处 DatagramPacket 里面持有的就是字节数组，我们就取出里面包含的字节数
- 此处就指定了：是哪个字节数组、从哪开始构造、构造多长

2. 根据请求计算响应

请求（request）：客户端主动给服务器发起的数据
响应（response）：服务器给客户端返回的数据

此处是一个回显服务器，响应就是请求

public void start() throws IOException {  
    System.out.println("服务器启动！");  
    //通过一个死循环来不停地处理请求  
    while(true) {  
        //1. 读取客户端的请求并解析  
        DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);  
        socket.receive(requestPacket);  
        //将收到的二进制 byte[] 数据转换成字符串  
        String request = new String(requestPacket.getData(),0,requestPacket.getLength());  
  
        //2. 根据请求计算响应  
        String response = process(request);  
    }
}  
  
//请求是什么，响应就是什么  
private String process(String request) {  
    return request;  
}

3. 将响应写回客户端

此时需要主动的将数据通过网卡发送回客户端

与 receive 相似， send 的参数是 DatagramPacket
- 我们就需要构造一个 DatagramPacket 对象，将其作为参数传递给 send
- 但此时不能使用空的数组来构造 DatagramPacket 对象
- 需要使用刚刚的 response 数据进行构造

public void start() throws IOException {  
    System.out.println("服务器启动！");  
    //通过一个死循环来不停地处理请求  
    while(true) {  
        //1. 读取客户端的请求并解析  
        DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);  
        socket.receive(requestPacket);  
        //将收到的二进制 byte[] 数据转换成字符串  
        String request = new String(requestPacket.getData(),0,requestPacket.getLength());  
  
        //2. 根据请求计算响应  
        String response = process(request);  
  
        //3. 把响应写回到客户端  
        DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,  
                requestPacket.getSocketAddress());  
        socket.send(responsePacket);  
    }
}  
  
//请求是什么，响应就是什么  
private String process(String request) {  
    return request;  
}

String 可以基于字节数组来构造，也可以随时取出里面的字节数组
response.getBytes().length 不能写成 response.length
- 前者是在获取字节数组，得到字节数组的长度，单位是“字节”
- 后者是在获取字符串中字符的个数，单位是“字符”
UDP 有一个特点——无连接
- 所谓的连接，就是通信双方保存对方的信息（IP+端口号）
- 就是说 DatagramSocket 这个对象中，不持有对方（客户端）和 IP 端口的，进行 send 的时候，就需要在 send 的数据包里，把要“发给谁”这样的信息，写进去，才能够正确的把数据进行返回
- 所以要将信息也作为参数，传入 responsePacket 中
  - 客户端刚才给服务器发了一个请求 requestPacket，这个包记录了这个数据是从哪来，从哪来就让它回哪去，所以直接获取这个 requestPacket 的信息就可以了
  - 客户端的 IP 和端口就都包含在 requestPacket.getSocketAddress() 中
  - 后续往外发送数据包的时候，就知道该发去哪了 >- 相比之下，TCP 代码中，因为 TCP 是有连接的，则无需关心对端的 IP 和端口，只管发送数据即可

如果字符串里都是英文字母/阿拉伯数字/英文标点符号的话，都是 ASCII 编码的，一个字符也就是一个字节这么长
如果字符串里有中文，是 UTF8 编码的，一个中文就是 3 个字节
UTF8 也是能兼容 ASCII，当使用 UTF8 表示英文的时候，和 ASCII 表示英文是完全相同的

完整代码

import java.io.IOException;  
import java.net.DatagramPacket;  
import java.net.DatagramSocket;  
import java.net.SocketException;  
  
public class UdpEchoServer {  
    private DatagramSocket socket = null;  
  
    public UdpEchoServer(int port) throws SocketException {  
        socket = new DatagramSocket(port);  
    }  
    
    public void start() throws IOException {  
        System.out.println("服务器启动！");  
        //通过一个死循环来不停地处理请求  
        while(true) {  
            //1. 读取客户端的请求并解析  
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);  
            socket.receive(requestPacket);  
            //将收到的二进制 byte[] 数据转换成字符串  
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());  
  
            //2. 根据请求计算响应  
            String response = process(request);  
  
            //3. 把响应写回到客户端  
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,  
                    requestPacket.getSocketAddress());  
            socket.send(responsePacket);  
  
            //4. 打印日志  
            System.out.printf("[%s:%d req=%s, res=%s\n",requestPacket.getAddress(),requestPacket.getPort(),request,response);  
        }    
    }  
	
	
    //请求是什么，响应就是什么  
    private String process(String request) {  
        return request;  
    }  
	
	
    public static void main(String[] args) throws IOException {  
        UdpEchoServer server = new UdpEchoServer(9090);  
        server.start();  
    }
}