黏包-黏包的成因、解决方式及struct模块初识、文件的上传和下载

黏包：


同时执行多条命令之后，得到的结果很可能只有一部分，在执行其他命令的时候又接收到之前执行的另外一部分结果，这种显现就是黏包。

只有TCP协议中才会产生黏包，UDP协议中不会有黏包（udp协议中数据会直接丢失，俗称丢包）

#面试
#首先只有在TCP协议中才有黏包现象，是因为TCP协议是面向流的协议，
#在发送的数据传输的过程中还有缓存机制来避免数据丢失
#因此在连续发送小数据的时候，以及接收大小不符的时候，都容易产生黏包现象
#本质是不知道客户端发送的数据长度

面试中解释黏包

#连续send两个小数据
#两个recv，第一个recv特别小

#面试
#首先只有在TCP协议中才有黏包现象，是因为TCP协议是面向流的协议，
#在发送的数据传输的过程中还有缓存机制来避免数据丢失
#因此在连续发送小数据的时候，以及接收大小不符的时候，都容易产生黏包现象
#本质是不知道客户端发送的数据长度

#服务端发送数据，经过系统内存，客户端接收，在TCP协议中，如果服务端发送数据过大，或者客户端接收数据过少，超过的数据就会滞纳在内存中
#从而产生了黏包。但是在UDP过程中则直接丢包了
#本质问题，不知道客户端发送的数据长度

#在TCP中  如果发送端发送了3次，3次总数据大小为10，接收端如果只接收一次，接收大小>10,那么这3次会合起来一起被接收
#以为TCP中的优化算法，当几次数据又小又连续，会合并发送（需要又小又连续）
#因为一次性接收，只需要经历一次网络延时，提高接收效率，
#并且只要接收方足够大，它会一次性把这三次数据都给合并接收，即使此处有3次接收
#比如此处 ret1和ret2接收都为空，连续的小数据被ret接收了
# ret = conn.recv(1024)
# print(ret)
# ret1 = conn.recv(1024) #此时ret1和ret2接收到的空，是因为数据都被ret接收了，本来是阻塞的，等待消息传入。
# ret2 = conn.recv(1024) #但是此时客户端close了，会默认发送空消息过来（根据windows版本不同，也可能直接报错），刚好被ret1和ret2接收了。
# print(ret1,ret2)

#多个send小的数据连在一起，会发生黏包现象，是TCP内部优化算法造成的
#注意这几个send必须又短又连续且发送间隔非常短暂（0.01秒都不行）

黏包问题总结

#UDP不会黏包，但是udp会丢包
#tcp会黏包，但是不会丢包

# 黏包成因：
# TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。
# 收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，
# 使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。
# 这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。

# 当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。
# MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。
# 大部分网络设备的MTU都是1500。如果本机的MTU比网关的MTU大，大的数据包就会被拆开来传送，
# 这样会产生很多数据包碎片，增加丢包率，降低网络速度。

# 1.是因为tcp的拆包机制，使得消息没有边界
# 2.当发送端缓冲区的长度大于网卡的MTU时，产生了数据包碎片

黏包成因-蛮看看就好

黏包的发现：


socket模块中，TCP协议的黏包问题发现：（用到了subprocess模块）

import socket
import subprocess
ip_port = (‘127.0.0.1‘,8898)
buffer_size = 10240

sk = socket.socket()
sk.bind(ip_port)
sk.listen()

conn,addr = sk.accept()
while True:
    cmd = input(‘>>>>> ‘)
    if cmd == ‘q‘:
        break
    conn.send(cmd.encode(‘utf-8‘))
    ret = conn.recv(buffer_size).decode(‘utf-8‘)
    # ret2 = conn.recv(buffer_size).decode(‘utf-8‘)
    print(ret)
    # print(ret2)

conn.close()
sk.close()

serve端-黏包

import socket
import subprocess
sk = socket.socket()
sk.connect((‘127.0.0.1‘,8898))

while True:
    cmd = sk.recv(1024).decode(‘gbk‘)
    ret = subprocess.Popen(cmd,shell=True,
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE
                           )
    std_out = ‘stdout: ‘+(ret.stdout.read()).decode(‘gbk‘)
    std_err = ‘stderr: ‘+(ret.stderr.read()).decode(‘gbk‘)
    print(std_out)
    print(std_err)
    sk.send(std_out.encode(‘utf-8‘))
    sk.send(std_err.encode(‘utf-8‘))
sk.close()

client端-黏包

黏包自己的小分析：

#服务端发送数据，经过系统内存，客户端接收，在TCP协议中，如果服务端发送数据过大，或者客户端接收数据过少，超过的数据就会滞纳在内存中（内核态用户态）
#从而产生了黏包。但是在UDP过程中则直接丢包了
#本质问题，不知道客户端发送的数据长度

import socket
sk = socket.socket()
sk.bind((‘127.0.0.1‘,8898))
sk.listen()

conn,addr = sk.accept()

#在TCP中  如果发送端发送了3次，3次总数据大小为10，接收端如果只接收一次，接收大小>10,那么这3次会合起来一起被接收
#以为TCP中的优化算法，当几次数据又小又连续，会合并发送（需要又小又连续）
#因为一次性接收，只需要经历一次网络延时，提高接收效率，
#并且只要接收方足够大，它会一次性把这三次数据都给合并接收，即使此处有3次接收
#比如此处 ret1和ret2接收都为空，连续的小数据被ret接收了
ret = conn.recv(1024)
print(ret)
ret1 = conn.recv(1024) #此时ret1和ret2接收到的空，是因为数据都被ret接收了，本来是阻塞的，等待消息传入。
ret2 = conn.recv(1024) #但是此时客户端close了，会默认发送空消息过来（根据windows版本不同，也可能直接报错），刚好被ret1和ret2接收了。
print(ret1,ret2)

conn.close()
sk.close()

#多个send小的数据连在一起，会发生黏包现象，是TCP内部优化算法造成的
#注意这几个send必须又短又连续且发送间隔非常短暂（0.01秒都不行）

server-黏包问题分析

import socket,time
sk = socket.socket()
sk.connect((‘127.0.0.1‘,8898))

sk.send(b‘hello‘)
time.sleep(0.01) #此时 hello会单独发送，下面两句才一起发送
sk.send(b‘he22‘)
sk.send(b‘33llo‘)

#多个send小的数据连在一起，会发生黏包现象，是TCP内部优化算法造成的
#注意这几个send必须又短又连续且发送间隔非常短暂（0.01秒都不行）

# import time
# time.sleep(5)
sk.close()

client-黏包问题分析

黏包的解决


有两种方式：

1.比较low的方法：及优劣点分析

import socket

sk = socket.socket()
sk.bind((‘127.0.0.1‘,8898))
sk.listen()
conn,addr = sk.accept()

while True:
    cmd = input(‘>>>>> ‘)
    if cmd == ‘q‘:
        break
    conn.send(cmd.encode(‘gbk‘))
    len_num = conn.recv(1024).decode(‘utf-8‘)
    conn.send(b‘ok‘)
    len_num = int(len_num)
    ret = conn.recv(len_num).decode(‘gbk‘)
    print(ret)

conn.close()
sk.close()

#好处：确定了我到底要接收多大的数据
    #要在文件中配置了一个配置项：就是每一次recv的大小  buffer = 4096
    #当我们要发送大数据的时候，要明确的告诉接收方要发送多大的数据，以便接收方能够准确的接收到所有数据
    #多用在文件传输的过程中
        #大文件的传输 一定是按照字节读 每一次读固定的字节
        #传输的过程中 发送端一边读一边传，接收端一边收一边写
        #send这个大文件之前，35672字节 send(4096)-....-send(4096)---->0
        #resv这个大文件之前，35672字节 send(4096)-....-send(4096)---->0

#不好的地方：
    #多了一次交互
    #send sendto 在超过一定范围的时候，都会报错
    #程序的内存管理

server端-方法的好处和坏处

import socket
import subprocess

sk = socket.socket()
sk.connect((‘127.0.0.1‘,8898))

while True:
    cmd = sk.recv(1024).decode(‘gbk‘)
    if cmd == ‘q‘:
        break
    ret = subprocess.Popen(cmd,shell=True,
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE)
    std_out = ret.stdout.read()  #注意read本身就是bytes类型。
    std_err = ret.stderr.read()  #此处read完后，类似从list中pop，管道中的值就取出来没了，类似队列
    len_num = str(len(std_out) + len(std_err))
    sk.send(len_num.encode(‘utf-8‘))
    sk.recv(1024)

    sk.send(std_out)
    sk.send(std_err)
sk.close()

client端

2.用struct模块解决黏包问题，及struct模块初识

import socket
import subprocess
import struct
sk = socket.socket()
sk.bind((‘127.0.0.1‘,8898))
sk.listen()
conn,addr = sk.accept()

while True:
    cmd = input(‘>>>>> ‘)
    if cmd == ‘q‘:
        break
    conn.send(cmd.encode(‘gbk‘))
    len_byte = conn.recv(4)         #通过struct模块，确定知道传过来的int为4个字节，这里只收取4个字节，保证不黏包
    len_num = struct.unpack(‘i‘,len_byte)[0]  #获取到传过来的数字，也就是接下来要接收数据的大小
    ret = conn.recv(len_num).decode(‘gbk‘)    #通过len，知道接下来要接收多大的数据，从而不管发送端发了几次，这边可以一次性接收
    print(ret)

conn.close()
sk.close()

server端-struct

import socket
import subprocess
import struct
sk = socket.socket()
sk.connect((‘127.0.0.1‘,8898))

while True:
    cmd = sk.recv(1024).decode(‘gbk‘)
    if cmd == ‘q‘:
        break
    ret = subprocess.Popen(cmd,shell=True,
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE)
    std_out = ret.stdout.read()  #注意read本身就是bytes类型。
    std_err = ret.stderr.read()  #此处read完后，类似从list中pop，管道中的值就取出来没了，类似队列
    len_num = len(std_out) + len(std_err)
    len_byt = struct.pack(‘i‘,len_num)
    sk.send(len_byt)
    sk.send(std_out)
    sk.send(std_err)
sk.close()

client端-struct

import struct
#模块可以把一个数字 转换为 一个bytes类型 （二进制）  然后再转回数字类型
#以int为例  int转换后的bytes类型长度为 4字节，以元组的方式返回 (int,)
#除了int 还有 float double  long  等等
#其中，int将在以后很长的时间里都只使用int

num_byte = struct.pack(‘i‘,4096)
print(num_byte)      #b‘\x00\x10\x00\x00‘
print(len(num_byte)) #长度为4

num_tup = struct.unpack(‘i‘,num_byte)
print(num_tup)          #(4096,)
print(type(num_tup[0])) #<class ‘int‘>

#通过struct模块，我们就将int转换为长度为4的bytes，就可以通过先recv(4)，获取到一个int类型
# 这个int类型表示接下来要接收的数据大小
#和黏包问题解决中比较low的方法比较，省去了一个交互步骤，不用我收到len大小后，再send(b‘ok‘)来避免 len 被黏包

struct模块初识

练习：


大文件的上传和下载

import os
import json
import socket
import struct
bufer = 1024
ip_port = (‘127.0.0.1‘,8898)
sk = socket.socket()
sk.bind(ip_port)
sk.listen()
conn,addr = sk.accept()

len_bytes = conn.recv(4)   #！！！！！这里怎么可以出错，struct传过来的int 就是4字节
len_head = struct.unpack(‘i‘,len_bytes)[0]
head_json = conn.recv(len_head).decode(‘utf-8‘)
head = json.loads(head_json)
filesize = head[‘filesize‘]
with open(head[‘file_name‘],‘wb‘) as f:
    while filesize:
        print(filesize)
        if filesize >= bufer:
            file_write = conn.recv(bufer)
            f.write(file_write)
            filesize -= bufer
        else:
            file_write = conn.recv(filesize)
            f.write(file_write)
            break
conn.close()
sk.close()

server

import os
import json
import socket
import struct
bufer = 1024
ip_port = (‘127.0.0.1‘,8898)
sk = socket.socket()
sk.connect(ip_port)

head = {‘file_path‘:r‘D:\python-全栈九期\day33‘,
        ‘file_name‘:‘04 python fullstack s9day33 ftp作业分析.mp4‘,
        ‘filesize‘:None}
file_path = os.path.join(head[‘file_path‘],head[‘file_name‘]) #join的用法写错了 ！！！
filesize = os.path.getsize(file_path)
head[‘filesize‘] = filesize
head_json = json.dumps(head)
head_bytes = head_json.encode(‘utf-8‘)

#开始用struct转换报头长度
len_head = len(head_bytes)
head_pack = struct.pack(‘i‘,len_head)
sk.send(head_pack)
sk.send(head_bytes)
with open(file_path,‘rb‘) as f:  #！！！这里rb写成了wb
    while filesize:
        print(filesize)
        if filesize >= bufer:
            content = f.read(bufer)
            sk.send(content)
            filesize -= bufer
        else:
            content = f.read(filesize)
            sk.send(content)
            break
sk.close()

client

原文地址：https://www.cnblogs.com/gkx0731/p/9727223.html

时间： 2024-10-31 22:53:12

黏包-黏包的成因、解决方式及struct模块初识、文件的上传和下载的相关文章

Servlet方式实现文件的上传和下载

文件的上传和下载需要两个jar包  commons-fileupload-1.2.2.jar和commons-io-2.0.1.jar JSP页面 <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Trans

springmvc和servlet下的文件上传和下载（存文件目录和存数据库Blob两种方式）

项目中涉及了文件的上传和下载,以前在struts2下做过,今天又用springmvc做了一遍,发现springmvc封装的特别好,基本不用几行代码就完成了,下面把代码贴出来: FileUpAndDown.jsp <%@ page language="java" contentType="text/html; charset=UTF-8"%> <html> <head> <title>using commons Uplo

Java实现文件的上传下载（含源代码和jar包）

1.需要使用的jar包 链接:https://pan.baidu.com/s/1IaxQRSwfzxDpe4w4JiaEKw 提取码:xwtz 2.如果想实现文件的下载,需要创建一张表,表的结构为 id url(id为查找依据,url为文件名即可) 2.文件的上传 该方法我是建立在SpringBoot框架中实现的,实际上这并不是必要的. 主要的是参数file是上传的文件信息,即路径相关.path的路径为获取的,使用与linux与windows系统,如果服务器固定,可以将path路径写成绝对路径.

nexus搭建maven私服及私服jar包上传和下载

nexus搭建maven私服及私服jar包上传和下载 标签: nexus管理maven库snapshot 2017-06-28 13:02 844人阅读 评论(0) 收藏 举报 分类: Maven(1) 版权声明:本文为博主原创文章,未经博主允许不得转载. 一.nexus搭建maven私服及相关介绍 1.下载nexus-2.12.0-01-bundle.zip(版本随意) 2.以管理员身份运行cmd,cd进入解压文件的bin目录,执行nexus.bat install 若未以管理员身份运行则安装

Python入门学习-DAY32-链接循环与通信循环，粘包问题，远程控制，文件上传与下载

链接循环与通信循环 服务端 from socket import * IP = '127.0.0.1' PORT = 8181 ADDRESS = (IP, PORT) BUFSIZE = 1024 server = socket(AF_INET, SOCK_STREAM) server.bind(ADDRESS) server.listen(5) tag=True while tag: conn, addr = server.accept() while tag: try: data = co

springmvc和servlet在上传和下载文件（保持文件夹和存储数据库Blob两种方式）

参与该项目的文件上传和下载.一旦struts2下完成,今天springmvc再来一遍.发现springmvc特别好包,基本上不具备的几行代码即可完成,下面的代码贴: FileUpAndDown.jsp <%@ page language="java" contentType="text/html; charset=UTF-8"%> <html> <head> <title>using commons Upload to

使用Kindeditor的多文件(图片)上传时出现上传失败的解决办法/使用Flash上传多文件(图片)上传时上传失败的解决办法

近来用户反映希望我们把在线编辑器中的多图片上传功能实现,因为他们在编辑商品描述时经常会有一次上传多张图片的需求,如果要逐张选择的话效率很低,客户的需求就是我们的追求,很快我们就把完善功能排到了日程表中,要求尽快实现. 我们在项目中使用的在线编辑器是Kindeditor4.1.10,它们的多文件上传插件是使用Flash实现的,原本应该就是能使用的,但为什么老是显示上传失败的,百度了一下前人的经验和教训,出现这种情况,有两种可能:1)上传的目标文件夹没有写权限,导致上传的文件无法进行写操作,所以上传

Myeclipse中文件已经上传到服务器目录下，文件也没有被占用，但是页面中无法读取和使用问题的解决方法

这个问题是由于Myeclipse中文件不同步引起的.在Myeclipse中,工程文件是由Myeclipse自动扫描添加的,如果在外部修改了工程目录中的文件但又关闭了自动刷新功能,则会引起文件不同步.此外,在外部没有修改Myeclipse工程中的文件也有可能引起该问题. 解决方法: 有两种解决方法: 1)手动刷新.即在Myeclipse的工程目录中,右键refresh(或者按下F5). 2)配置Myeclipse的选项: a)Myeclipse启动时,刷新workspace,即勾选:window-

Mac下svn问题——“.a”(静态库)文件无法上传解决

“.a”(静态库)文件无法上传(svn工具) 网上查询了一下,说是Xcode自带的svn和Versions以及一些其它工具都不能上传".a"文件. 解决办法如下: 1.打开终端,输入cd,空格,然后将需要上传的.a文件所在的文件夹(不是.a文件)拖拽到终端(此办法无需输入繁琐的路径,快捷方便) ,回车: 2.之后再输入如下命令:svn add libGoogleAnalytics.a,回车: 3.之后会出现:A  (bin)  libGoogleAnalytics.a 表示添加成功,打