论坛 › python › day18-网络编程（下）

飞的雨 发表于 2024-4-22 11:49:40

day18-网络编程（下）

1. OSI 7层模型



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

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

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

每一层各司其职，最终保证数据呈现在到用户手中。
简单的可以理解为发快递：将数据外面套了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在传输数据报前不⽤在客户和服务器之间建⽴⼀个连接， 且没有超时重发等机制， 故⽽传输速度很快。
常见的有：语音通话、视频通话、实时游戏画面 等。
[*]TCP（Transmission Control Protocol，传输控制协议）是面向连接的协议，也就是说，在收发数据前，必须和对方建立可靠的连接，然后再进行收发数据。
常见有：网站、手机APP数据获取等。
2.1 UDP和TCP 示例代码

UDP示例如下：

[*]服务端
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind(('127.0.0.1', 8002))

while True:
    data, (host, port) = server.recvfrom(1024) # 阻塞
    print(data, host, port)
    server.sendto("好的".encode('utf-8'), (host, port))
[*]客户端
import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while True:
    text = input("请输入要发送的内容：")
    if text.upper() == 'Q':
      break
    client.sendto(text.encode('utf-8'), ('127.0.0.1', 8002))
    data, (host, port) = client.recvfrom(1024)
    print(data.decode('utf-8'))

client.close()
TCP示例如下：

[*]服务端
import socket

# 1.监听本机的IP和端口
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('127.0.0.1', 8001))
sock.listen(5)

while True:
    # 2.等待，有人来连接（阻塞）
    conn, addr = sock.accept()

    # 3.等待，连接者发送消息（阻塞）
    client_data = conn.recv(1024)
    print(client_data)

    # 4.给连接者回复消息
    conn.sendall(b"hello world")

    # 5.关闭连接
    conn.close()

# 6.停止服务端程序
sock.close()
[*]客户端
import socket

# 1. 向指定IP发送连接请求
client = socket.socket()
client.connect(('127.0.0.1', 8001))

# 2. 连接成功之后，发送消息
client.sendall(b'hello')

# 3. 等待，消息的回复（阻塞）
reply = client.recv(1024)
print(reply)

# 4. 关闭连接
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) # 数据字节长度 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) # 数据字节长度
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层模型
import os
import json
import socket
import struct


def recv_data(conn, chunk_size=1024):
    # 获取头部信息：数据长度
    has_read_size = 0
    bytes_list = []
    while has_read_size < 4:
      chunk = conn.recv(4 - has_read_size)
      has_read_size += len(chunk)
      bytes_list.append(chunk)
    header = b"".join(bytes_list)
    data_length = struct.unpack('i', header)

    # 获取数据
    data_list = []
    has_read_data_size = 0
    while has_read_data_size < data_length:
      size = chunk_size if (data_length - has_read_data_size) > chunk_size else data_length - has_read_data_size
      chunk = conn.recv(size)
      data_list.append(chunk)
      has_read_data_size += len(chunk)

    data = b"".join(data_list)

    return data


def recv_file(conn, save_file_name, chunk_size=1024):
    save_file_path = os.path.join('files', save_file_name)
    # 获取头部信息：数据长度
    has_read_size = 0
    bytes_list = []
    while has_read_size < 4:
      chunk = conn.recv(4 - has_read_size)
      bytes_list.append(chunk)
      has_read_size += len(chunk)
    header = b"".join(bytes_list)
    data_length = struct.unpack('i', header)

    # 获取数据
    file_object = open(save_file_path, mode='wb')
    has_read_data_size = 0
    while has_read_data_size < data_length:
      size = chunk_size if (data_length - has_read_data_size) > chunk_size else data_length - has_read_data_size
      chunk = conn.recv(size)
      file_object.write(chunk)
      file_object.flush()
      has_read_data_size += len(chunk)
    file_object.close()


def run():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # IP可复用
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

    sock.bind(('127.0.0.1', 8001))
    sock.listen(5)
    while True:
      conn, addr = sock.accept()

      while True:
            # 获取消息类型
            message_type = recv_data(conn).decode('utf-8')
            if message_type == 'close':# 四次挥手，空内容。
                print("关闭连接")
                break
            # 文件：{'msg_type':'file', 'file_name':"xxxx.xx" }
            # 消息：{'msg_type':'msg'}
            message_type_info = json.loads(message_type)
            if message_type_info['msg_type'] == 'msg':
                data = recv_data(conn)
                print("接收到消息：", data.decode('utf-8'))
            else:
                file_name = message_type_info['file_name']
                print("接收到文件，要保存到：", file_name)
                recv_file(conn, file_name)

      conn.close()
    sock.close()


if __name__ == '__main__':
    run()
[*]UDP和TCP的区别
import os
import json
import socket
import struct


def send_data(conn, content):
    data = content.encode('utf-8')
    header = struct.pack('i', len(data))
    conn.sendall(header)
    conn.sendall(data)


def send_file(conn, file_path):
    file_size = os.stat(file_path).st_size
    header = struct.pack('i', file_size)
    conn.sendall(header)

    has_send_size = 0
    file_object = open(file_path, mode='rb')
    while has_send_size < file_size:
      chunk = file_object.read(2048)
      conn.sendall(chunk)
      has_send_size += len(chunk)
    file_object.close()


def run():
    client = socket.socket()
    client.connect(('127.0.0.1', 8001))

    while True:
      """
      请发送消息，格式为：
            - 消息：msg|你好呀
            - 文件：file|xxxx.png
      """
      content = input(">>>")# msg or file
      if content.upper() == 'Q':
            send_data(client, "close")
            break
      input_text_list = content.split('|')
      if len(input_text_list) != 2:
            print("格式错误，请重新输入")
            continue

      message_type, info = input_text_list

      # 发消息
      if message_type == 'msg':

            # 发消息类型
            send_data(client, json.dumps({"msg_type": "msg"}))

            # 发内容
            send_data(client, info)

      # 发文件
      else:
            file_name = info.rsplit(os.sep, maxsplit=1)[-1]

            # 发消息类型
            send_data(client, json.dumps({"msg_type": "file", 'file_name': file_name}))

            # 发内容
            send_file(client, info)

    client.close()


if __name__ == '__main__':
    run()
[*]TCP的三次握手和四次挥手
[*]为什么会有粘包？如何解决？
[*]如何让socket请求变成非阻塞？
[*]IO多路复用的作用？
# ################### 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.close()

[*]IO多路复用 + 非阻塞 + socket服务端，可以让服务端同时处理多个客户端的请求。
[*]IO多路复用 + 非阻塞 + socket客户端，可以向服务端同时发起多个请求。

作业（模块大作业）

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

[*]客户端

[*]用户注册，注册成功之后，在服务端的指定目录下为此用户创建一个文件夹，该文件夹下以后存储当前用户的数据（类似于网盘）。
[*]用户登录
[*]查看网盘目录下的所有文件（一级即可），ls命令
[*]上传文件，如果网盘已存在则重新上传（覆盖）。
[*]下载文件（进度条）
# ################### socket服务端（接收者）###################
import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

sock.setblocking(False) # 加上就变为了非阻塞

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.setblocking(False) # 加上就变为了非阻塞

# 非阻塞
client.connect(('127.0.0.1', 8001))

client.sendall('alex正在吃翔'.encode('utf-8'))

client.close()

[*]服务端

[*]支持注册，并为用户初始化相关目录。
# ################### socket服务端 ###################
import select
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setblocking(False)# 加上就变为了非阻塞
server.bind(('127.0.0.1', 8001))
server.listen(5)

inputs = # socket对象列表 ->

while True:
    # 当 参数1 序列中的socket对象发生可读时（accetp和read），则获取发生变化的对象并添加到 r列表中。
    # r = []
    # r =
    # r = [第一个客户端连接conn,]
    # r =
    # r = [第一个客户端连接conn，第二个客户端连接conn]
    # r = [第二个客户端连接conn,]
    r, w, e = select.select(inputs, [], [], 0.05)
    for sock in r:
      # server
      if sock == server:
            conn, addr = sock.accept() # 接收新连接。
            print("有新连接")
            # conn.sendall()
            # conn.recv("xx")
            inputs.append(conn)
      else:
            data = sock.recv(1024)
            if data:
                print("收到消息：", data.decode("utf-8"))
            else:
                print("关闭连接")
                inputs.remove(sock)
        # 干点其他事 20s
"""
优点：
        1. 干点其他的事。
        2. 让服务端支持多个客户端同时来连接。
"""
[*]支持登录
[*]支持查看当前用户网盘目录下的所有文件。
[*]支持上传
[*]支持下载

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

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

查看完整版本: day18-网络编程（下）