day_27

目录

• 回顾
  • 软件开发架构
    • C/S
    • B/S
• 网络变成历史
  • 互联网协议
  • socket套接字
• 今日内容
• subprocess模块
• 粘包问题
  • 粘包的两种情况
• 解决粘包问题
• 上传大文件
• UDP
• 聊天室
• socketserver

回顾

软件开发架构

C/S

client：客户端

server：服务端

优点：软件的使用稳定，并且可以节省网络

缺点：

1. 若用户想在同一个设备上使用多个软件，必须下载多个客户端
2. 软件的每一次更新，客户端也必须更新

B/S

Browser：浏览器（客户端）
Server：服务端

优点：

以浏览器充当客户端，无需用户下载多个软件，也无需用户下载更新软件版本，

直接在浏览器上访问需要使用的软件

缺点：

消耗网络资源过大，当网络不稳定时，软件的使用也会不稳定

网络变成历史

互联网协议

应用层，表示层，会话层，传输层，网络层，数据链路层，物理层

socket套接字

recv的数据是从内存中获取

今日内容

subprocess模块

可以通过代码执行操作系统的终端命令并返回终端执行命令后的结果

import subprocess

cmd = input('cmd>>:')  # dir

obj = subprocess.Popen(
    # cmd命令
    cmd,
    # Shell=True
    shell=True,
    # 返回正确结果参数
    stdout=subprocess.PIPE,
    # 返回错误结果参数 error
    stderr=subprocess.PIPE
)

result = obj.stdout.read() + obj.stderr.read()

print(result.decode('gbk'))

粘包问题

只有TCP有粘包现象，UDP永远不会粘包

粘包的两种情况

1. 发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）
2. 接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

解决粘包问题

struct模块

解决粘包问题的核心就是：为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据。

'''
- struct模块:
    是一个可以将很长的数据的长度，压缩成固定的长度的一个标记（数据报头）。
'''

import struct

# 打包压缩
# i:模式，会将数据长度压缩成4个bytes
str1 = 'wataaaaaaaaaaaaa'

# 报头
# 模拟客户端
headers = struct.pack('i', 10000)
print(headers)

print(len(headers))  # 4
# client.send(headers)

# 模拟服务端
# headers = conn.recv(4)
data_len = struct.unpack('i', headers)  # (10000,)
print(data_len[0])  # 真实数据长度10000

服务端

from socket import *
import subprocess
import struct
import json

server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8000))
server.listen(5)

print('start...')
while True:
    conn, client_addr = server.accept()
    print(conn, client_addr)

    while True:
        cmd = conn.recv(1024)

        obj = subprocess.Popen(cmd.decode('utf8'),
                               shell=True,
                               stderr=subprocess.PIPE,
                               stdout=subprocess.PIPE)

        stderr = obj.stderr.read()
        stdout = obj.stdout.read()

        # 制作报头
        header_dict = {
            'filename': 'a.txt',
            'total_size': len(stdout) + len(stderr),
            'hash': 'xasf123213123'
        }
        header_json = json.dumps(header_dict)
        header_bytes = header_json.encode('utf8')

        # 1. 先把报头的长度len(header_bytes)打包成4个bytes，然后发送
        conn.send(struct.pack('i', len(header_bytes)))
        # 2. 发送报头
        conn.send(header_bytes)
        # 3. 发送真实的数据
        conn.send(stdout)
        conn.send(stderr)

    conn.close()

server.close()

客户端

from socket import *
import json
import struct

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8000))

while True:
    cmd = input('please enter your cmd you want>>>')

    if len(cmd) == 0: continue

    client.send(cmd.encode('utf8'))

    # 1. 先收4个字节，这4个字节中包含报头的长度
    header_len = struct.unpack('i', client.recv(4))[0]

    # 2. 再接收报头
    header_bytes = client.recv(header_len)

    # 3. 从包头中解析出想要的东西
    header_json = header_bytes.decode('utf8')
    header_dict = json.loads(header_json)
    total_size = header_dict['total_size']

    # 4. 再收真实的数据
    recv_size = 0
    res = b''
    while recv_size < total_size:
        data = client.recv(1024)

        res += data
        recv_size += len(data)

    print(res.decode('utf8'))

client.close()

上传大文件

客户端

import socket
import struct
import json

client = socket.socket()

client.connect(
    ('127.0.0.1', 9527)
)


# 1.打开一个视频文件，获取视频数据大小
with open(r'D:jason真实写真集.mp4', 'rb') as f:
    movie_bytes = f.read()
    # 关闭文件

# 2.为视频文件组织一个字典，字典内有视频的名称，视频大小
send_dic = {
    'file_name': 'jason真实写真集.mp4',
    'file_size': len(movie_bytes)  # 10G
}

# 3.先打包字典，发送headers报头，再发送真实字典数据
json_data = json.dumps(send_dic)
bytes_data = json_data.encode('utf-8')
headers = struct.pack('i', len(bytes_data))
# 发送报头
client.send(headers)
# 发送真实字典数据
client.send(bytes_data)

# 4.接着发送真实视频文件数据
init_data = 0
num = 1
with open(r'D:jason真实写真集.mp4', 'rb') as f:
    while init_data < len(movie_bytes):
        # 最后一次获取，有多少拿多少
        send_data = f.read(1024)
        print(send_data, num)
        num += 1
        # 每次发送1024数据
        client.send(send_data)
        # 为初始发送数据 + 已发送数据的长度
        init_data += len(send_data)

服务端

import socket
import json
import struct
server = socket.socket()
server.bind(
    ('127.0.0.1', 9527)
)
server.listen(5)

while True:
    conn, addr = server.accept()
    try:
        # 先接收字典报头
        headers = conn.recv(4)

        # 解包获取字典真实数据长度
        data_len = struct.unpack('i', headers)[0]

        # 获取字典真实数据
        bytes_data = conn.recv(data_len)

        # 反序列得到字典
        back_dic = json.loads(bytes_data.decode('utf-8'))

        print(back_dic)

        # 拿到字典的文件名，文件大小
        file_name = back_dic.get('file_name')
        file_size = back_dic.get('file_size')

        init_data = 0
        # 1.以文件名打开文件，准备写入
        with open(file_name, 'wb') as f:

            # 一点一点接收文件，并写入
            while init_data < file_size:
                data = conn.recv(1024)
                # 2.开始写入视频文件
                f.write(data)
                init_data += len(data)

            print(f'{file_name}接收完毕!')

    except Exception as e:
        print(e)
        break

conn.close()

UDP

UDP是一种传输协议。

        1. 不需要建立双向管道。
           2. 不会粘包
           3. 客户端给服务端发送数据，不需要等待服务端返回接收成功
           4. 数据容易丢失，数据不安全。

TCP: 就好比在打电话。
UDP: 就好比在发短信。

聊天室

服务端

import socket

server = socket.socket(type=socket.SOCK_DGRAM)

server.bind(
    ('127.0.0.1', 9527)
)

while True:

    # 服务端接收客户端传过来的消息
    msg, addr = server.recvfrom(1024)  # (消息，客户端地址)
    msg1, addr1 = server.recvfrom(1024)  # (消息，客户端地址)
    msg2, addr2 = server.recvfrom(1024)  # (消息，客户端地址)

    print(addr)
    print(addr1)
    print(addr2)
    print(msg.decode('utf-8'))
    print(msg1.decode('utf-8'))
    print(msg2.decode('utf-8'))

    # 服务端往客户端发送消息
    send_msg = input('服务端发送消息:').encode('utf-8')
    server.sendto(send_msg, addr)
    server.sendto(send_msg, addr1)
    server.sendto(send_msg, addr2)

客户端

import socket

client = socket.socket(type=socket.SOCK_DGRAM)

server_ip_port = ('127.0.0.1', 9527)

while True:
    send_msg = input('客户端1: ').encode('utf-8')

    # 发送消息必须要加上对方地址
    client.sendto(send_msg, server_ip_port)

    # 能接收任何人的消息
    msg = client.recv(1024)

    print(msg.decode('utf-8'))

socketserver

python内置模块，可以简化socket套接字服务端的代码。

• 简化TCP与UDP服务端代码
• 要创建一个类