8.4 粘包问题

粘包问题发生的原因：

1.发送端需要等缓冲区满才发送出去，造成粘包(发送数据时间间隔很短,数据了很小,会合到一起,产生粘包),这样接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。

2.接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

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

8.41 stract模块

1、把整型数字转成bytes类型 2、转成的bytes是固定长度的

import struct
?
res=struct.pack('i',20332)    # i:整型 
print(res,len(res))          # b'lO\x00\x00'   4
?
res2=struct.unpack('i',res)
print(res2[0])              # 20332

8.42 利用stract模块解决粘包

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头（报头中含有真实数据长度），然后再取真实数据

服务端：

from socket import *
import subprocess
import struct
........
while True:
    conn,client_addr=server.accept() #(连接对象，客户端的ip和端口)
    print(client_addr)
    while True:
        try:
            cmd=conn.recv(1024)
            obj=subprocess.Popen(cmd.decode('utf-8'),# dir
                                 shell=True,
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE
                                 )
            stdout=obj.stdout.read()
            stderr=obj.stderr.read()
?
            total_size=len(stdout) + len(stderr)# 1、制作固定长度的报头 # 430
            header=struct.pack('i',total_size) 
?
            conn.send(header)                  # 2、发送报头
?
            conn.send(stdout)                  #3、发送真实的数据
            conn.send(stderr)                  #subprocess返回byte类型，但需要gbk解码
        except ConnectionResetError:
            break
?
    conn.close()
server.close()

客户端：

from socket import *
import struct
..........
while True:
    cmd=input('>>>: ').strip()
    if not cmd:continue
    client.send(cmd.encode('utf-8'))          # dir
?
    header=client.recv(4)                    #1、先收固定长度的报头
?
    total_size=struct.unpack('i',header)[0]    #2、解析报头
    print(total_size)                        # 430
   
    recv_size=0                             #3、根据报头内的信息，收取真实的数据
    res=b''
    while recv_size < total_size:
        recv_data=client.recv(1024)
        res+=recv_data
        recv_size+=len(recv_data)
    print(res.decode('gbk'))
client.close()

8.43 自定义报头

我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，字典然后json序列化，编码成byte类型，然后用struck将数据长度打包成4个字节（4个自己足够用了）

发送时：

先发报头长度，再编码报头内容然后发送，最后发真实内容

接收时：先收报头长度，用struct取出来，根据取出的长度收取报头内容，然后解码，反序列化，从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

服务端：

from socket import *
import subprocess
import struct
import json
...........
while True:
    conn,client_addr=server.accept() #(连接对象，客户端的ip和端口)
    print(client_addr)
    while True:
        try:
            cmd=conn.recv(1024)
            obj=subprocess.Popen(cmd.decode('utf-8'),
                                 shell=True,
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE
                                 )
            stdout=obj.stdout.read()
            stderr=obj.stderr.read()
?
            header_dic={                            # 1、制作报头
                'total_size':len(stdout) + len(stderr),
                'md5':'123svsaef123sdfasdf',
                'filename':'a.txt'
            }
            header_json = json.dumps(header_dic)
            header_bytes = header_json.encode('utf-8')
?
            header_size=len(header_bytes)             # 2、先发送报头的长度
            conn.send(struct.pack('i',header_size))
?
            conn.send(header_bytes)                  # 3、发送报头
?
            conn.send(stdout)                        # 4、发送真实的数据
            conn.send(stderr)
        except ConnectionResetError:
            break
    conn.close()
server.close()

客户端：

from socket import *
import struct
import json
.........
while True:
    cmd=input('>>>: ').strip()
    if not cmd:continue
    client.send(cmd.encode('utf-8'))
    
    header_size=struct.unpack('i',client.recv(4))[0]     #1、先收报头的长度
    header_bytes=client.recv(header_size)               #2、接收报头
?
    header_json=header_bytes.decode('utf-8')            #3、解析报头
    header_dic=json.loads(header_json)
    print(header_dic)
?
    total_size=he