ToB企服应用市场:ToB评测及商务社交产业平台

标题: day18-网络编程（下） [打印本页]

作者: 灌篮少年 时间: 2024-5-18 00:03
标题: day18-网络编程（下）
1. OSI 7层模型

OSI的7层模型对于各人来说可能不太好理解，所以我们通过一个案例来讲解：

假设，你在欣赏器上输入了一些关键字，内部通过DNS找到对应的IP后，再发送数据时内部会做如下的事：

应用层：规定数据的格式。
1. "GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n"
复制代码
表现层：对应用层数据的编码、压缩（解压缩）、分块、加密（解密）等任务。
1. "GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8')
复制代码
会话层：负责与目标建立、中断连接。
1. 在发送数据之前，需要会先发送 “连接” 的请求，与远程建立连接后，再发送数据。当然，发送完毕之后，也涉及中断连接的操作。
复制代码
传输层：建立端口到端口的通讯，其实就确定双方的端口信息。
1. 数据："GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8')
2. 端口：
3. - 目标：80
4. - 本地：6784
复制代码
网络层：标记目标IP信息（IP协议层）
1. 数据："GET /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8')
2. 端口：
3. - 目标：80
4. - 本地：6784IP： - 目标IP：110.242.68.3（百度） - 本地IP：192.168.10.1
复制代码
数据链路层：对数据举行分组并设置源和目标mac地址
1. 数据："POST /s?wd=你好 HTTP/1.1\r\nHost:www.baidu.com\r\n\r\n你好".encode('utf-8')
2. 端口：
3. - 目标：80
4. - 本地：6784
5. IP：
6. - 目标IP：110.242.68.3（百度）
7. - 本地IP：192.168.10.1
8. MAC：
9. - 目标MAC：FF-FF-FF-FF-FF-FF
10. - 本机MAC：11-9d-d8-1a-dd-cd
复制代码
物理层：将二进制数据在物理媒体上传输。
1. 通过网线将二进制数据发送出去
复制代码

每一层各司其职，最终保证数据呈如今到用户手中。
简单的可以理解为发快递：将数据外面套了7个箱子，最终用户收到箱子时必要打开7个箱子才气拿到数据。而在运输的过程中有些箱子是会被拆开并替换的，比方：

最终运送目标：上海 ~ 北京（中途可能需要中转站），在中转站会会打开箱子查看信息，在进行转发。
- 对于二级中转站（二层交换机）：拆开数据链路层的箱子，查看mac地址信息。
- 对于三级中转站（路由器或三层交换机）：拆开网络层的箱子，查看IP信息。

复制代码

在开发过程中其实只能表现：应用层、表现层、会话层、传输层，其他层的处理都是在网络装备中自动完成的。

import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('110.242.68.3', 80)) # 向服务端发送了数据包
key = "你好"
# 应用层
content = "GET /s?wd={} http1.1\r\nHost:www.baidu.com\r\n\r\n".format(key)
# 表示层
content = content.encode("utf-8")
client.sendall(content)
result = client.recv(8196)
print(result.decode('utf-8'))
# 会话层 & 传输层
client.close()

复制代码

2. UDP和TCP协议

协议，其实就是规定连接、收发数据的一些规定。
在OSI的传输层除了界说端口信息以外，常见的还可以指定UDP或TCP的协议，协议差别连接和传输数据的细节也会差别。

UDP（User Data Protocol）用户数据报协议，是⼀个⽆连接的简单的⾯向数据报的传输层协议。 UDP不提供可靠性，它只是把应⽤程序传给IP层的数据报发送出去，但是并不能保证它们能到达⽬的地。由于UDP在传输数据报前不⽤在客户和服务器之间建⽴⼀个连接，且没有超时重发等机制，故⽽传输速度很快。
1. 常见的有：语音通话、视频通话、实时游戏画面等。
复制代码
TCP（Transmission Control Protocol，传输控制协议）是面向连接的协议，也就是说，在收发数据前，必须和对方建立可靠的连接，然后再举行收发数据。
1. 常见有：网站、手机APP数据获取等。
复制代码

2.1 UDP和TCP 示例代码

UDP示比方下：

服务端
1. import socket
3. server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
4. server.bind(('127.0.0.1', 8002))
6. while True:
7. data, (host, port) = server.recvfrom(1024) # 阻塞
8. print(data, host, port)
9. server.sendto("好的".encode('utf-8'), (host, port))
复制代码
客户端
1. import socket
3. client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
4. while True:
5. text = input("请输入要发送的内容：")
6. if text.upper() == 'Q':
7. break
8. client.sendto(text.encode('utf-8'), ('127.0.0.1', 8002))
9. data, (host, port) = client.recvfrom(1024)
10. print(data.decode('utf-8'))
12. client.close()
复制代码

TCP示比方下：

服务端
1. import socket
3. # 1.监听本机的IP和端口
4. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
5. sock.bind(('127.0.0.1', 8001))
6. sock.listen(5)
8. while True:
9. # 2.等待，有人来连接（阻塞）
10. conn, addr = sock.accept()
12. # 3.等待，连接者发送消息（阻塞）
13. client_data = conn.recv(1024)
14. print(client_data)
16. # 4.给连接者回复消息
17. conn.sendall(b"hello world")
19. # 5.关闭连接
20. conn.close()
22. # 6.停止服务端程序
23. sock.close()
复制代码
客户端
1. import socket
3. # 1. 向指定IP发送连接请求
4. client = socket.socket()
5. client.connect(('127.0.0.1', 8001))
7. # 2. 连接成功之后，发送消息
8. client.sendall(b'hello')
10. # 3. 等待，消息的回复（阻塞）
11. reply = client.recv(1024)
12. print(reply)
14. # 4. 关闭连接
15. client.close()
复制代码

2.2 TCP三次握手和四次挥手

这是一个常见的面试题。

0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Source Port | Destination Port |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Sequence Number |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Acknowledgment Number |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Data | |U|A|P|R|S|F| |
| Offset| Reserved |R|C|S|S|Y|I| Window |
| | |G|K|H|T|N|N| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Checksum | Urgent Pointer |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Options | Padding |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| data |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

复制代码

网络中的双方想要基于TCP连接举行通讯，必须要经过：
<ul>创建连接，客户端和服务端要举行三次握手。

# 服务端
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('127.0.0.1', 8001))
sock.listen(5)
while True:
conn, addr = sock.accept() # 等待客户端连接
...

复制代码

# 客户端
import socket
client = socket.socket()
client.connect(('127.0.0.1', 8001)) # 发起连接

复制代码

客户端服务端
1. SYN-SENT --> <seq=100><CTL=SYN> --> SYN-RECEIVED
2. ESTABLISHED <-- <seq=300><ack=101><CTL=SYN,ACK> <-- SYN-RECEIVED
3. ESTABLISHED --> <seq=101><ack=301><CTL=ACK> --> ESTABLISHED
At this point, both the client and server have received an acknowledgment of the connection. The steps 1, 2 establish the connection parameter (sequence number) for one direction and it is acknowledged. The steps 2, 3 establish the connection parameter (sequence number) for the other direction and it is acknowledged. With these, a full-duplex communication is established.

复制代码

传输数据

在收发数据的过程中，只有有数据的传送就会有应答（ack），如果没有ack，那么内部会尝试重复发送。

复制代码

关闭连接，客户端和服务端要举行4次挥手。

import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('127.0.0.1', 8001))
sock.listen(5)
while True:
conn, addr = sock.accept()
...
conn.close() # 关闭连接
sock.close()

复制代码

import socket
client = socket.socket()
client.connect(('127.0.0.1', 8001))
...
client.close() # 关闭连接

复制代码

TCP A TCP B
1. FIN-WAIT-1 --> <seq=100><ack=300><CTL=FIN,ACK> --> CLOSE-WAIT
2. FIN-WAIT-2 <-- <seq=300><ack=101><CTL=ACK> <-- CLOSE-WAIT
3. TIME-WAIT <-- <seq=300><ack=101><CTL=FIN,ACK> <-- LAST-ACK
4. TIME-WAIT --> <seq=101><ack=301><CTL=ACK> --> CLOSED

复制代码

# socket客户端（发送者）
import socket
client = socket.socket()
client.connect(('127.0.0.1', 8001))
client.sendall('alex正在吃'.encode('utf-8'))
client.sendall('翔'.encode('utf-8'))
client.close()
# socket服务端（接收者）
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('127.0.0.1', 8001))
sock.listen(5)
conn, addr = sock.accept()
client_data = conn.recv(1024)
print(client_data.decode('utf-8'))
conn.close()
sock.close()

复制代码

# socket客户端（发送者）
import socket
client = socket.socket()
client.connect(('127.0.0.1', 8001))
client.sendall('alex正在吃'.encode('utf-8'))
client.sendall('翔'.encode('utf-8'))
client.close()
# socket服务端（接收者）
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('127.0.0.1', 8001))
sock.listen(5)
conn, addr = sock.accept()
client_data = conn.recv(1024)
print(client_data.decode('utf-8'))
conn.close()
sock.close() # 与服务端断开连接（四次挥手），默认会向服务端发送空数据。

复制代码

IO多路复用 + 非阻塞，可以实现让TCP的客户端同时发送多个请求，比方：去某个网站发送下载图片的请求。

import socket
import struct
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('127.0.0.1', 8001))
sock.listen(5)
conn, addr = sock.accept()
# 固定读取4字节
header1 = conn.recv(4)
data_length1 = struct.unpack('i', header1)[0] # 数据字节长度 21
has_recv_len = 0
data1 = b""
while True:
length = data_length1 - has_recv_len
if length > 1024:
lth = 1024
else:
lth = length
chunk = conn.recv(lth) # 可能一次收不完，自己可以计算长度再次使用recv收取，直到收完为止。 1024*8 = 8196
data1 += chunk
has_recv_len += len(chunk)
if has_recv_len == data_length1:
break
print(data1.decode('utf-8'))
# 固定读取4字节
header2 = conn.recv(4)
data_length2 = struct.unpack('i', header2)[0] # 数据字节长度
data2 = conn.recv(data_length2) # 长度
print(data2.decode('utf-8'))
conn.close()
sock.close()

复制代码

基于 IO多路复用 + 非阻塞的特性，无论编写socket的服务端和客户端都可以提升性能。其中

IO多路复用，监测socket对象是否有变革（是否连接成功？是否有数据到来等）。
非阻塞，socket的connect、recv过程不再等候。

注意：IO多路复用只能用来监听 IO对象是否发生变革，常见的有：文件是否可读写、电脑终端装备输入和输出、网络请求（常见）。
在Linux操作系统化中 IO多路复用有三种模式，分别是：select，poll，epoll。（windows 只支持select模式）

监测socket对象是否新连接到来 or 新数据到来。

import socket
import struct
client = socket.socket()
client.connect(('127.0.0.1', 8001))
# 第一条数据
data1 = 'alex正在吃'.encode('utf-8')
header1 = struct.pack('i', len(data1))
client.sendall(header1)
client.sendall(data1)
# 第二条数据
data2 = '翔'.encode('utf-8')
header2 = struct.pack('i', len(data2))
client.sendall(header2)
client.sendall(data2)
client.close()

复制代码

增补：socket + 非阻塞+ IO多路复用（IO操作对象都可以监测 + 文件）。
总结

OSI 7层模型
1. import os
2. import json
3. import socket
4. import struct
7. def recv_data(conn, chunk_size=1024):
8. # 获取头部信息：数据长度
9. has_read_size = 0
10. bytes_list = []
11. while has_read_size < 4:
12. chunk = conn.recv(4 - has_read_size)
13. has_read_size += len(chunk)
14. bytes_list.append(chunk)
15. header = b"".join(bytes_list)
16. data_length = struct.unpack('i', header)[0]
18. # 获取数据
19. data_list = []
20. has_read_data_size = 0
21. while has_read_data_size < data_length:
22. size = chunk_size if (data_length - has_read_data_size) > chunk_size else data_length - has_read_data_size
23. chunk = conn.recv(size)
24. data_list.append(chunk)
25. has_read_data_size += len(chunk)
27. data = b"".join(data_list)
29. return data
32. def recv_file(conn, save_file_name, chunk_size=1024):
33. save_file_path = os.path.join('files', save_file_name)
34. # 获取头部信息：数据长度
35. has_read_size = 0
36. bytes_list = []
37. while has_read_size < 4:
38. chunk = conn.recv(4 - has_read_size)
39. bytes_list.append(chunk)
40. has_read_size += len(chunk)
41. header = b"".join(bytes_list)
42. data_length = struct.unpack('i', header)[0]
44. # 获取数据
45. file_object = open(save_file_path, mode='wb')
46. has_read_data_size = 0
47. while has_read_data_size < data_length:
48. size = chunk_size if (data_length - has_read_data_size) > chunk_size else data_length - has_read_data_size
49. chunk = conn.recv(size)
50. file_object.write(chunk)
51. file_object.flush()
52. has_read_data_size += len(chunk)
53. file_object.close()
56. def run():
57. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
58. # IP可复用
59. sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
61. sock.bind(('127.0.0.1', 8001))
62. sock.listen(5)
63. while True:
64. conn, addr = sock.accept()
66. while True:
67. # 获取消息类型
68. message_type = recv_data(conn).decode('utf-8')
69. if message_type == 'close': # 四次挥手，空内容。
70. print("关闭连接")
71. break
72. # 文件：{'msg_type':'file', 'file_name':"xxxx.xx" }
73. # 消息：{'msg_type':'msg'}
74. message_type_info = json.loads(message_type)
75. if message_type_info['msg_type'] == 'msg':
76. data = recv_data(conn)
77. print("接收到消息：", data.decode('utf-8'))
78. else:
79. file_name = message_type_info['file_name']
80. print("接收到文件，要保存到：", file_name)
81. recv_file(conn, file_name)
83. conn.close()
84. sock.close()
87. if __name__ == '__main__':
88. run()
复制代码
UDP和TCP的区别
1. import os
2. import json
3. import socket
4. import struct
7. def send_data(conn, content):
8. data = content.encode('utf-8')
9. header = struct.pack('i', len(data))
10. conn.sendall(header)
11. conn.sendall(data)
14. def send_file(conn, file_path):
15. file_size = os.stat(file_path).st_size
16. header = struct.pack('i', file_size)
17. conn.sendall(header)
19. has_send_size = 0
20. file_object = open(file_path, mode='rb')
21. while has_send_size < file_size:
22. chunk = file_object.read(2048)
23. conn.sendall(chunk)
24. has_send_size += len(chunk)
25. file_object.close()
28. def run():
29. client = socket.socket()
30. client.connect(('127.0.0.1', 8001))
32. while True:
33. """
34. 请发送消息，格式为：
35. - 消息：msg|你好呀
36. - 文件：file|xxxx.png
37. """
38. content = input(">>>") # msg or file
39. if content.upper() == 'Q':
40. send_data(client, "close")
41. break
42. input_text_list = content.split('|')
43. if len(input_text_list) != 2:
44. print("格式错误，请重新输入")
45. continue
47. message_type, info = input_text_list
49. # 发消息
50. if message_type == 'msg':
52. # 发消息类型
53. send_data(client, json.dumps({"msg_type": "msg"}))
55. # 发内容
56. send_data(client, info)
58. # 发文件
59. else:
60. file_name = info.rsplit(os.sep, maxsplit=1)[-1]
62. # 发消息类型
63. send_data(client, json.dumps({"msg_type": "file", 'file_name': file_name}))
65. # 发内容
66. send_file(client, info)
68. client.close()
71. if __name__ == '__main__':
72. run()
复制代码
TCP的三次握手和四次挥手
为什么会有粘包？如何解决？
如何让socket请求酿成非阻塞？
IO多路复用的作用？
1. # ################### socket服务端（接收者）###################
2. import socket
4. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
5. sock.bind(('127.0.0.1', 8001))
6. sock.listen(5)
8. # 阻塞
9. conn, addr = sock.accept()
11. # 阻塞
12. client_data = conn.recv(1024)
13. print(client_data.decode('utf-8'))
15. conn.close()
16. sock.close()
19. # ################### socket客户端（发送者） ###################
20. import socket
22. client = socket.socket()
24. # 阻塞
25. client.connect(('127.0.0.1', 8001))
27. client.sendall('alex正在吃翔'.encode('utf-8'))
29. client.close()
复制代码
- IO多路复用 + 非阻塞 + socket服务端，可以让服务端同时处理多个客户端的请求。
- IO多路复用 + 非阻塞 + socket客户端，可以向服务端同时发起多个请求。

作业（模块大作业）

请基于TCP协议实现一个网盘系统，包含客户端、服务端，各自需求如下：

客户端
- 用户注册，注册成功之后，在服务端的指定目录下为此用户创建一个文件夹，该文件夹下以后存储当前用户的数据（类似于网盘）。
- 用户登录
- 检察网盘目录下的全部文件（一级即可），ls命令
- 上传文件，如果网盘已存在则重新上传（覆盖）。
- 下载文件（进度条）
  1. # ################### socket服务端（接收者）###################
  2. import socket
  4. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  6. sock.setblocking(False) # 加上就变为了非阻塞
  8. sock.bind(('127.0.0.1', 8001))
  9. sock.listen(5)
  11. # 非阻塞
  12. conn, addr = sock.accept()
  14. # 非阻塞
  15. client_data = conn.recv(1024)
  16. print(client_data.decode('utf-8'))
  18. conn.close()
  19. sock.close()
  21. # ################### socket客户端（发送者） ###################
  22. import socket
  24. client = socket.socket()
  26. client.setblocking(False) # 加上就变为了非阻塞
  28. # 非阻塞
  29. client.connect(('127.0.0.1', 8001))
  31. client.sendall('alex正在吃翔'.encode('utf-8'))
  33. client.close()
  复制代码
服务端
- 支持注册，并为用户初始化相关目录。
  1. # ################### socket服务端 ###################
  2. import select
  3. import socket
  5. server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  6. server.setblocking(False) # 加上就变为了非阻塞
  7. server.bind(('127.0.0.1', 8001))
  8. server.listen(5)
  10. inputs = [server, ] # socket对象列表 -> [server, 第一个客户端连接conn ]
  12. while True:
  13. # 当参数1 序列中的socket对象发生可读时（accetp和read），则获取发生变化的对象并添加到 r列表中。
  14. # r = []
  15. # r = [server,]
  16. # r = [第一个客户端连接conn,]
  17. # r = [server,]
  18. # r = [第一个客户端连接conn，第二个客户端连接conn]
  19. # r = [第二个客户端连接conn,]
  20. r, w, e = select.select(inputs, [], [], 0.05)
  21. for sock in r:
  22. # server
  23. if sock == server:
  24. conn, addr = sock.accept() # 接收新连接。
  25. print("有新连接")
  26. # conn.sendall()
  27. # conn.recv("xx")
  28. inputs.append(conn)
  29. else:
  30. data = sock.recv(1024)
  31. if data:
  32. print("收到消息：", data.decode("utf-8"))
  33. else:
  34. print("关闭连接")
  35. inputs.remove(sock)
  36. # 干点其他事 20s
  37. """
  38. 优点：
  39. 1. 干点其他的事。
  40. 2. 让服务端支持多个客户端同时来连接。
  41. """
  复制代码
- 支持登录
- 支持检察当前用户网盘目录下的全部文件。
- 支持上传
- 支持下载

参考代码见：https://files.cnblogs.com/files/blogs/814578/网盘系统（参考代码）.zip?t=1713753389&download=true

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)