网络编程笔记(3)——解决黏包问题

内容目录：

解决黏包问题：

• 提前发送文件的大小
• 使用struct模块
• 定制报文

内容详细：

1.发送之前先发文件大小

优点：

• 确定了到底要接收多大的数据
• 要在文件中配置一个配置项：每次recv文件的大小，buffer = 4096（建议使用这个）
• 当我们要发送大数据时，明确告知接收方要发送多大的数据，以便接收方能准确的接收到所有的数据
• 多用在文件传输的过程中：
  • 大文件的传输，一定是按照字节读，每次读固定大小的字节
  • 传输的过程中，一边读一边传；接收端：一边收一边写入文件

缺点：

• 多了一次接收交互

注意：

• send 或 sendto超过一定范围的时候都会报错（设备默认的范围大小）
• 写文件传输的时候必须考虑程序的内存管理

# server端：
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()

conn,addr = sk.accept()

while True:
    cmd = input('>>>')
    if cmd == 'q':
        conn.send(b'q')
        break
    conn.send(cmd.encode('gbk'))
    num = conn.recv(1024).decode('utf-8')   #接收到了client端发过来的字节总数
    conn.send(b'ok')
    res = conn.recv(int(num)).decode('gbk') #获取了接收的总字节数，设置进要接收的值里面，就可以动态的感知要发送的数据了
    print(res)

conn.close()
sk.close()

#Client端：
import socket
import subprocess

sk = socket.socket()
sk.connect(('127.0.0.1',8080))
while True:
    cmd = sk.recv(1024).decode('gbk')   #因为Windows传输都为GBK编码的
    if cmd == 'q':
        break
    res = subprocess.Popen(cmd,shell=True,          #PIPE为管道/队列，只能取一次，取完就结束了
                           stdout=subprocess.PIPE,  #stdout为命令的输出
                           stderr=subprocess.PIPE)  #stderr为命令错误的提示信息
    std_out = res.stdout.read() #从队列中取出命令
    std_err = res.stderr.read() #从队列中取出错误命令信息
    sk.send(str(len(std_out)+len(std_err)).encode('utf-8'))  #计算要发送的字节总数并发送过去
    sk.recv(4096)       #一般不要超过这个数字，否则会超过设备内存
    sk.send(std_out)
    sk.send(std_err)
sk.close()

2.使用struct模块

• 什么是固定长度的bytes

• 为什么要固定长度bytes?

  • 因为发送数据前，先发数据的长度，接收方接收长度。如果固定长度的话就省略了一步收发数据长度的次数

  #发送端需要借助struct模块
  import struct
  ret = struct.pack('i',2048) #'i'代表int，就是即将要把一个数字转换成固定长度的bytes类型
  print(ret)
  
  #接收端：
  num = struct.unpack('i',ret)	#此时num为元组tuple类型
  print(num[0])	#获取数据长度2048
  #这样接收方只需要接收固定的长度就可以获取整个数据的长度了
  

  # 使用struct模块收发信息
  # Server端：
  import socket
  import struct
  sk = socket.socket()
  sk.bind(('127.0.0.1',8080))
  sk.listen()
  
  conn,addr = sk.accept()
  
  while True:
      cmd = input('>>>')
      if cmd == 'q':
          conn.send(b'q')
          break
      conn.send(cmd.encode('gbk'))
      num = conn.recv(4)   #接收到了client端发过来的4个字节数（二进制），不管多大始终是4个字节
      num = struct.unpack('i',num)[0]   #把4个字节数二进制unpack，得到总字节数：num
      res = conn.recv(int(num)).decode('gbk') #获取了接收的总字节数，设置进要接收的值里面，就可以动态的感知要发送的数据了
      print(res)
  
  conn.close()
  sk.close()
  
  # Client端：
  import socket
  import struct
  import subprocess
  
  sk = socket.socket()
  sk.connect(('127.0.0.1',8080))
  while True:
      cmd = sk.recv(1024).decode('gbk')   #因为Windows传输都为GBK编码的
      if cmd == 'q':
          break
      res = subprocess.Popen(cmd,shell=True,          #PIPE为管道/队列，只能取一次，取完就结束了
                             stdout=subprocess.PIPE,  #stdout为命令的输出
                             stderr=subprocess.PIPE)  #stderr为命令错误的提示信息
      std_out = res.stdout.read() #从队列中取出命令
      std_err = res.stderr.read() #从队列中取出错误命令信息
      len_num = len(std_out) + len(std_err)#计算要发送的字节总数并发送过去
      num_by = struct.pack('i',len_num)	#使用模块pack进去总字节数，发送过去的始终是4个字节
      sk.send(num_by)     #发送了4个字节
      sk.send(std_out)
      sk.send(std_err)
  sk.close()
  

3.定制报文报头

• 我们在网络上传输的所有数据，都叫数据包

• 数据包里的所有数据，都叫报文

• 报文里不只有发送的数据，还有ip地址，MAC地址，端口号

• 所有的报文都有报头

• 可以自定义报文头

  head = {'filename':'test','filesize':409600,'filetype':'txt','filepath':r'userin'}
  # 先发送报头的长度              #接收4个字节的报头长度
  # send(head)                   #根据这4个字节获取报头
  # send(file)发送数据文件        #从报头中获取filesize，然后设置大小接收文件
  

• 例子：上传文件

  # Server端：
  # 实现一个大文件的上传或下载
  # 配置文件，IP地址，端口号
  import socket
  import struct
  import json
  sk = socket.socket()
  sk.bind(('127.0.0.1',8090))
  sk.listen()
  buffer = 1024       #注意，如果设置过大会设备缓存会出错，导致文件接收不完整
  
  conn,addr = sk.accept()
  #接收
  head_len = conn.recv(4)
  head_len = struct.unpack('i',head_len)[0]
  json_head = conn.recv(head_len).decode('utf-8')
  head = json.loads(json_head)
  filesize = head['filesize']
  
  with open(head['filename'],'wb')as f:
      while filesize:
          if filesize >= buffer:
              content = conn.recv(buffer)
              f.write(content)
              filesize -= buffer
          else:
              content = conn.recv(filesize)
              f.write(content)
              filesize = 0
          print('====>',len(content))
      print(filesize)
  conn.close()
  sk.close()
  print(head['filesize'])
  
  # Client端：
  # 发送端
  import os
  import json
  import struct
  import socket
  sk = socket.socket()
  sk.connect(('127.0.0.1',8090))
  buffer = 1024
  
  # 发送文件
  head = {'filename':'02 python fullstack s9day47-web框架的本质.mp4',
          'filepath':r'D:硬盘文件老男孩pythonPython全栈9期（第02部分）：并发编程+数据库+前端3. 前端开发day47',
          'filesize':None}
  filepath = os.path.join(head['filepath'],head['filename'])
  filesize = os.path.getsize(filepath)
  head['filesize'] = filesize
  json_head = json.dumps(head)    #字典转成了字符串
  bytes_head = json_head.encode('utf-8')  #字符串转bytes
  
  #计算head的长度
  head_len = len(bytes_head)      #报头的长度
  pack_len = struct.pack('i',head_len)
  sk.send(pack_len)           #先发报头的长度
  sk.send(bytes_head)         #再发送bytes类型的报头
  with open(filepath,'rb')as f:
      while filesize:
          if filesize >= buffer:
              content = f.read(buffer)        #每次读出来的内容
              sk.send(content)
              filesize -= buffer
          else:
              content = f.read(filesize)
              sk.send(content)
              filesize = 0
  
  sk.close()