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个箱子才能拿到数据。而在运输的过程中有些箱子是会被拆开并替换的，例如：

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

复制代码

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

1. import socket
3. client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
4. client.connect(('110.242.68.3', 80)) # 向服务端发送了数据包
7. key = "你好"
8. # 应用层
9. content = "GET /s?wd={} http1.1\r\nHost:www.baidu.com\r\n\r\n".format(key)
10. # 表示层
11. content = content.encode("utf-8")
13. client.sendall(content)
14. result = client.recv(8196)
15. print(result.decode('utf-8'))
17. # 会话层 & 传输层
18. 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三次握手和四次挥手

这是一个常见的面试题。

1.     0                   1                   2                   3
2.     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
3.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
4.    |          Source Port          |       Destination Port        |
5.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
6.    |                        Sequence Number                        |
7.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
8.    |                    Acknowledgment Number                      |
9.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
10.    |  Data |           |U|A|P|R|S|F|                               |
11.    | Offset| Reserved  |R|C|S|S|Y|I|            Window             |
12.    |       |           |G|K|H|T|N|N|                               |
13.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
14.    |           Checksum            |         Urgent Pointer        |
15.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
16.    |                    Options                    |    Padding    |
17.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
18.    |                             data                              |
19.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

复制代码

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

1. # 服务端
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. while True:
9.     conn, addr = sock.accept() # 等待客户端连接
10.     ...

复制代码

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

复制代码

1.       客户端                                                服务端
3.   1.  SYN-SENT    --> <seq=100><CTL=SYN>               --> SYN-RECEIVED
5.   2.  ESTABLISHED <-- <seq=300><ack=101><CTL=SYN,ACK>  <-- SYN-RECEIVED
7.   3.  ESTABLISHED --> <seq=101><ack=301><CTL=ACK>       --> ESTABLISHED
9.       
10. 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.

复制代码

传输数据

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

复制代码

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

1. import socket
3. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
4. sock.bind(('127.0.0.1', 8001))
5. sock.listen(5)
6. while True:
7.     conn, addr = sock.accept()
8.         ...
9.     conn.close() # 关闭连接
10. sock.close()

复制代码

1. import socket
3. client = socket.socket()
4. client.connect(('127.0.0.1', 8001))
5. ...
6. client.close() # 关闭连接

复制代码

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

复制代码

1. # socket客户端（发送者）
2. import socket
4. client = socket.socket()
5. client.connect(('127.0.0.1', 8001))
7. client.sendall('alex正在吃'.encode('utf-8'))
8. client.sendall('翔'.encode('utf-8'))
10. client.close()
13. # socket服务端（接收者）
14. import socket
16. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
17. sock.bind(('127.0.0.1', 8001))
18. sock.listen(5)
19. conn, addr = sock.accept()
21. client_data = conn.recv(1024)
22. print(client_data.decode('utf-8'))
24. conn.close()
25. sock.close()

复制代码

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

复制代码

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

1. import socket
2. import struct
4. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
5. sock.bind(('127.0.0.1', 8001))
6. sock.listen(5)
7. conn, addr = sock.accept()
9. # 固定读取4字节
10. header1 = conn.recv(4)
11. data_length1 = struct.unpack('i', header1)[0] # 数据字节长度 21
12. has_recv_len = 0
13. data1 = b""
14. while True:
15.     length = data_length1 - has_recv_len
16.     if length > 1024:
17.         lth = 1024
18.     else:
19.         lth = length
20.     chunk = conn.recv(lth) # 可能一次收不完，自己可以计算长度再次使用recv收取，直到收完为止。 1024*8 = 8196
21.     data1 += chunk
22.     has_recv_len += len(chunk)
23.     if has_recv_len == data_length1:
24.         break
25. print(data1.decode('utf-8'))
27. # 固定读取4字节
28. header2 = conn.recv(4)
29. data_length2 = struct.unpack('i', header2)[0] # 数据字节长度
30. data2 = conn.recv(data_length2) # 长度
31. print(data2.decode('utf-8'))
33. conn.close()
34. sock.close()

复制代码

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

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

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

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

1. import socket
2. import struct
4. client = socket.socket()
5. client.connect(('127.0.0.1', 8001))
7. # 第一条数据
8. data1 = 'alex正在吃'.encode('utf-8')
10. header1 = struct.pack('i', len(data1))
12. client.sendall(header1)
13. client.sendall(data1)
15. # 第二条数据
16. data2 = '翔'.encode('utf-8')
17. header2 = struct.pack('i', len(data2))
18. client.sendall(header2)
19. client.sendall(data2)
21. 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

来源:https://www.cnblogs.com/sbhglqy/p/18150171
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！