1000字范文 > Python3之socket编程（TCP/UDP 粘包问题数据传输文件上传）

Python3之socket编程（TCP/UDP 粘包问题数据传输文件上传）

时间：2019-05-10 05:04:53

一、socket的定义

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

补充：也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序，而程序的pid是同一台机器上不同进程或者线程的标识

二、套接字发展史及分类

套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

三、套接字的工作流程

一个生活中的场景。你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。

生活中的场景就解释了套接字的工作原理

先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。

四、socket函数使用

socket函数用法

import socketsocket.socket(socket_family,socket_type,protocal=0)#socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。#获取tcp/ip套接字tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#获取udp/ip套接字udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)#由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。使用 'from socket import *',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能大幅减短我们的代码。#例如tcpSock = socket(AF_INET, SOCK_STREAM)

服务端套接字函数

s.bind() #绑定(主机,端口号)到套接字s.listen() #开始TCP监听s.accept() #被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数

s.connect()#主动初始化TCP服务器连接s.connect_ex() #connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数

s.recv() #接收TCP数据s.send() #发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)s.sendall() #发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)s.recvfrom() #接收UDP数据s.sendto()#发送UDP数据s.getpeername()#连接到当前套接字的远端的地址s.getsockname()#当前套接字的地址s.getsockopt()#返回指定套接字的参数s.setsockopt()#设置指定套接字的参数s.close() #关闭套接字

面向锁的套接字方法

s.setblocking()#设置套接字的阻塞与非阻塞模式s.settimeout()#设置阻塞套接字操作的超时时间s.gettimeout()#得到阻塞套接字操作的超时时间

面向文件的套接字方法

s.fileno()#套接字的文件描述符s.makefile() #创建一个与该套接字相关的文件

打电话的流程演示

服务端.py

import socketphone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机phone.bind(('127.0.0.1',8080)) #插电话卡phone.listen(5) #开机，backlogprint('starting....')conn,addr=phone.accept() #接电话print(conn)print('client addr',addr)print('ready to read msg')client_msg=conn.recv(1024) #收消息print('client msg: %s' %client_msg)conn.send(client_msg.upper()) #发消息conn.close()phone.close()

客户端.py

import socketphone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)phone.connect(('127.0.0.1',8080)) #拨通电话phone.send('hello'.encode('utf-8')) #发消息back_msg=phone.recv(1024)print(back_msg)phone.close()

输出

服务端：

starting....<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8080), raddr=('127.0.0.1', 65142)>client addr ('127.0.0.1', 65142)ready to read msgclient msg: b'hello'

客户端

b'HELLO'

五、基于TCP的套接字

tcp服务端

ss = socket() #创建服务器套接字ss.bind()#把地址绑定到套接字ss.listen()#监听链接inf_loop:#服务器无限循环cs = ss.accept() #接受客户端链接comm_loop: #通讯循环cs.recv()/cs.send() #对话(接收与发送)cs.close() #关闭客户端套接字ss.close() #关闭服务器套接字(可选)

tcp客户端

cs = socket() # 创建客户套接字cs.connect() # 尝试连接服务器comm_loop: # 通讯循环cs.send()/cs.recv() # 对话(发送/接收)cs.close() # 关闭客户套接字

socket通信流程与打电话流程类似，我们就以打电话为例来实现一个low版的套接字通信

服务端

import socketip_port=('127.0.0.1',9000) #电话卡BUFSIZE=1024#收发消息的尺寸s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机s.bind(ip_port) #手机插卡s.listen(5)#手机待机conn,addr=s.accept() #手机接电话# print(conn)# print(addr)print('接到来自%s的电话' %addr[0])msg=conn.recv(BUFSIZE) #听消息,听话print(msg,type(msg))conn.send(msg.upper())#发消息,说话conn.close()#挂电话s.close() #手机关机

客户端

import socketip_port=('127.0.0.1',9000)BUFSIZE=1024s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)s.connect_ex(ip_port) #拨电话s.send('nitouxiang nb'.encode('utf-8')) #发消息,说话(只能发送字节类型)feedback=s.recv(BUFSIZE) #收消息,听话print(feedback.decode('utf-8'))s.close() #挂电话

输出

服务端

接到来自127.0.0.1的电话b'nitouxiang nb' <class 'bytes'>

客户端

NITOUXIANG NB

上述流程的问题是，服务端只能接受一次链接，然后就彻底关闭掉了，实际情况应该是，服务端不断接受链接，然后循环通信，通信完毕后只关闭链接，服务器能够继续接收下一次链接，下面是修改版

服务端

import socketip_port = ('127.0.0.1',8081) #电话卡BUFSIZE=1024s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机s.bind(ip_port) #手机插卡s.listen(5) #手机待机while True: #新增接收链接循环,可以不停的接电话conn,addr=s.accept() #手机接电话print('接到来自%s的电话' %addr[0])while True: ##新增通信循环,可以不断的通信,收发消息msg=conn.recv(BUFSIZE) #听消息,听话if len(msg) == 0:break #如果不加,那么正在链接的客户端突然断开,recv便不再阻塞,死循环发生print(msg,type(msg))conn.send(msg.upper()) #发消息,说话conn.close()#挂电话s.close()#手机关机

客户端

import socketip_port=('127.0.0.1',8081)BUFSIZE=1024s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)s.connect_ex(ip_port) #拨电话while True: #新增通信循环,客户端可以不断发收消息msg=input('>>: ').strip()if len(msg) == 0:continues.send(msg.encode('utf-8')) #发消息,说话(只能发送字节类型)feedback=s.recv(BUFSIZE) #收消息,听话print(feedback.decode('utf-8'))s.close() #挂电话

补充：

在重启服务端时可能会遇到

这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址（如果不懂，请深入研究1.tcp三次握手，四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法）

解决办法

方法一

#加入一条socket配置，重用ip和端口phone=socket(AF_INET,SOCK_STREAM)phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加phone.bind(('127.0.0.1',8080))

方法二

发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，vi /etc/sysctl.conf编辑文件，加入以下内容：net.ipv4.tcp_syncookies = 1net.ipv4.tcp_tw_reuse = 1net.ipv4.tcp_tw_recycle = 1net.ipv4.tcp_fin_timeout = 30然后执行 /sbin/sysctl -p 让参数生效。net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

六、基于UDP的套接字

udp服务端

ss = socket() #创建一个服务器的套接字ss.bind() #绑定服务器套接字inf_loop: #服务器无限循环cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送)ss.close()# 关闭服务器套接字

udp客户端

cs = socket() # 创建客户套接字comm_loop:# 通讯循环cs.sendto()/cs.recvfrom() # 对话(发送/接收)cs.close() # 关闭客户套接字

示例

服务端

import socketip_port=('127.0.0.1',9000)BUFSIZE=1024udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)udp_server_client.bind(ip_port)while True:msg,addr=udp_server_client.recvfrom(BUFSIZE)print(msg,addr)udp_server_client.sendto(msg.upper(),addr)

客户端

import socketip_port=('127.0.0.1',9000)BUFSIZE=1024udp_server_client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)while True:msg=input('>>: ').strip()if not msg:continueudp_server_client.sendto(msg.encode('utf-8'),ip_port)back_msg,addr=udp_server_client.recvfrom(BUFSIZE)print(back_msg.decode('utf-8'),addr)

输出

客户端

>>: 123123 ('127.0.0.1', 9000)>>: 33 ('127.0.0.1', 9000)>>: 44 ('127.0.0.1', 9000)

服务端

b'123' ('127.0.0.1', 53066)b'3' ('127.0.0.1', 53066)b'4' ('127.0.0.1', 53066)

模拟QQ聊天，多个客户端和服务端通信

服务端

import socketip_port=('127.0.0.1',8081)udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #买手机udp_server_sock.bind(ip_port)while True:qq_msg,addr=udp_server_sock.recvfrom(1024)print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))back_msg=input('回复消息: ').strip()udp_server_sock.sendto(back_msg.encode('utf-8'),addr)

客户端1

import socketBUFSIZE=1024udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)qq_name_dic={'TOM':('127.0.0.1',8081),'JACK':('127.0.0.1',8081),'一棵树':('127.0.0.1',8081),'武大郎':('127.0.0.1',8081),}while True:qq_name=input('请选择聊天对象: ').strip()while True:msg=input('请输入消息,回车发送: ').strip()if msg == 'quit':breakif not msg or not qq_name or qq_name not in qq_name_dic:continueudp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))udp_client_socket.close()

客户端2

输出

客户端1

请选择聊天对象: JACK请输入消息,回车发送: 约不来自[127.0.0.1:8081]的一条消息:不约请输入消息,回车发送:

客户端2

请选择聊天对象: TOM请输入消息,回车发送: 123来自[127.0.0.1:8081]的一条消息:321请输入消息,回车发送:

服务端

来自[127.0.0.1:62851]的一条消息:123回复消息: 321来自[127.0.0.1:60378]的一条消息:约不回复消息: 不约

七、recv与recvfrom

发消息，都是将数据发送到己端的发送缓冲中，收消息都是从己端的缓冲区中收。

tcp：send发消息，recv收消息udp：sendto发消息，recvfrom收消息

1.send与sendinto

tcp是基于数据流的，而udp是基于数据报的：

send(bytes_data):发送数据流，数据流bytes_data若为空，自己这段的缓冲区也为空，操作系统不会控制tcp协议发空包sendinto(bytes_data,ip_port)：发送数据报，bytes_data为空，还有ip_port,所有即便是发送空的bytes_data,数据报其实也不是空的，自己这端的缓冲区收到内容，操作系统就会控制udp协议发包。

2.recv与recvfrom

tcp协议：

（1）如果收消息缓冲区里的数据为空，那么recv就会阻塞（阻塞很简单，就是一直在等着收）

（2）只不过tcp协议的客户端send一个空数据就是真的空数据，客户端即使有无穷个send空，也跟没有一个样。

（3）tcp基于链接通信

基于链接，则需要listen（backlog），指定半连接池的大小基于链接，必须先运行的服务端，然后客户端发起链接请求对于mac系统：如果一端断开了链接，那另外一端的链接也跟着完蛋recv将不会阻塞，收到的是空(解决方法是：服务端在收消息后加上if判断，空消息就break掉通信循环)对于windows/linux系统：如果一端断开了链接，那另外一端的链接也跟着完蛋recv将不会阻塞，收到的是空(解决方法是：服务端通信循环内加异常处理，捕捉到异常后就break掉通讯循环)

udp协议

（1）如果如果收消息缓冲区里的数据为“空”，recvfrom也会阻塞

（2）只不过udp协议的客户端sendinto一个空数据并不是真的空数据（包含：空数据+地址信息，得到的报仍然不会为空），所以客户端只要有一个sendinto（不管是否发送空数据，都不是真的空数据），服务端就可以recvfrom到数据。

（3）udp无链接

无链接，因而无需listen（backlog），更加没有什么连接池之说了无链接，udp的sendinto不用管是否有一个正在运行的服务端，可以己端一个劲的发消息，只不过数据丢失recvfrom收的数据小于sendinto发送的数据时，在mac和linux系统上数据直接丢失，在windows系统上发送的比接收的大直接报错只有sendinto发送数据没有recvfrom收数据，数据丢失

注意：

1.你单独运行上面的udp的客户端，你发现并不会报错，相反tcp却会报错，因为udp协议只负责把包发出去，对方收不收，我根本不管，而tcp是基于链接的，必须有一个服务端先运行着，客户端去跟服务端建立链接然后依托于链接才能传递消息，任何一方试图把链接摧毁都会导致对方程序的崩溃。

2.上面的udp程序，你注释任何一条客户端的sendinto，服务端都会卡住，为什么？因为服务端有几个recvfrom就要对应几个sendinto，哪怕是sendinto(b'')那也要有。

基于tcp先制作一个远程执行命令的程序（1：执行错误命令 2：执行ls 3：执行ifconfig）

客户端

import socketBUFSIZE=1024ip_port=('127.0.0.1',8080)s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)res=s.connect_ex(ip_port)while True:msg=input('>>: ').strip()if len(msg) == 0:continueif msg == 'quit':breaks.send(msg.encode('utf-8'))act_res=s.recv(BUFSIZE)print(act_res.decode('utf-8'),end='')

服务端

from socket import *import subprocessip_port=('127.0.0.1',8080)BUFSIZE=1024tcp_socket_server=socket(AF_INET,SOCK_STREAM)tcp_socket_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)tcp_socket_server.bind(ip_port)tcp_socket_server.listen(5)while True:conn,addr=tcp_socket_server.accept()print('客户端',addr)while True:cmd=conn.recv(BUFSIZE)if len(cmd) == 0:breakres=subprocess.Popen(cmd.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)stderr=res.stderr.read()stdout=res.stdout.read()conn.send(stderr)conn.send(stdout)

输出

客户端

>>: ls1.py客户端.py客户端1.py客户端2.py服务端.py>>: ifconfig en0en0: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 1500ether 78:4f:43:5b:a5:4c inet6 fe80::d0:d821:dbf0:3d67%en0 prefixlen 64 secured scopeid 0x5 inet 192.168.31.165 netmask 0xffffff00 broadcast 192.168.31.255nd6 options=201<PERFORMNUD,DAD>media: autoselectstatus: active>>: ifconfiglo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> mtu 16384options=1203<RXCSUM,TXCSUM,TXSTATUS,SW_TIMESTAMP>inet 127.0.0.1 netmask 0xff000000 inet6 ::1 prefixlen 128 inet6 fe80::1%lo0 prefixlen 64 scopeid 0x1 nd6 options=201<PERFORMNUD,DAD>gif0: flags=8010<POINTOPOINT,MULTICAST> mtu 1280stf0: flags=0<> mtu 1280en0: flags=8863<UP,BROADCAST,SMART,RUNNING,SIMPLEX,MULTICAST> mtu 1500ether 78:4f:43:5b:a5:4c inet6 fe80::d0:d821:dbf0:3d67%en0 prefixlen 64 secured scopeid 0x5 inet 192.168.31.165 netmask 0xffffff00 broadcast 192.168.31.255nd6 options=201<PERFORMNUD,DAD>media: autoselectstatus: activeen1: flags=963<UP,BROADCAST,SMART,RUNNING,PROMISC,SIMPLEX> mtu 1500options=60<TSO4,TSO6>ether e2:00:ec:98:eb:00 media: autoselect <full-duplex>status: inactiveen3: flags=963<UP,BROADCAST,SMART,RUNNING,PROMISC,SIMPLEX> mtu 1500options=60<TSO4,TSO6>ether e2:00:ec:98:eb:01 media: autoselect <full-duplex>status: inactiveen2: flags=963<UP,BROADCAST,SMART,RUNNING,PROMISC,SIMPLEX> mtu 1500>>: >>:

服务端

客户端 ('127.0.0.1', 58194)

上述程序是基于tcp的socket，在运行时会发生粘包

服务端

from socket import *import subprocessip_port=('127.0.0.1',9003)bufsize=1024udp_server=socket(AF_INET,SOCK_DGRAM)udp_server.bind(ip_port)while True:#收消息cmd,addr=udp_server.recvfrom(bufsize)print('用户命令----->',cmd)#逻辑处理res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdin=subprocess.PIPE,stdout=subprocess.PIPE)stderr=res.stderr.read()stdout=res.stdout.read()#发消息udp_server.sendto(stderr,addr)udp_server.sendto(stdout,addr)udp_server.close()

客户端

from socket import *ip_port=('127.0.0.1',9003)bufsize=1024udp_client=socket(AF_INET,SOCK_DGRAM)while True:msg=input('>>: ').strip()udp_client.sendto(msg.encode('utf-8'),ip_port)data,addr=udp_client.recvfrom(bufsize)print(data.decode('utf-8'),end='')

上述程序是基于udp的socket，在运行时永远不会发生粘包

注意注意注意：

res=subprocess.Popen(cmd.decode('utf-8'),

shell=True,

stderr=subprocess.PIPE,

stdout=subprocess.PIPE)

的结果的编码是以当前所在的系统为准的，如果是windows，那么res.stdout.read()读出的就是GBK编码的，在接收端需要用GBK解码且只能从管道里读一次结果

八、粘包

1.什么是粘包

粘包：发送方发送两个字符串”hello”+”world”，接收方却一次性接收到了”helloworld”。

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

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

补充：

分包：发送方发送字符串”helloworld”，接收方却接收到了两个字符串”hello”和”world”。

TCP是以段（Segment）为单位发送数据的，建立TCP链接后，有一个最大消息长度（MSS）。如果应用层数据包超过MSS，就会把应用层数据包拆分，分成两个段来发送。这个时候接收端的应用层就要拼接这两个TCP包，才能正确处理数据。

补充：

一个socket收发消息的原理

2.粘包如何产生

TCP为了提高网络的利用率，会使用一个叫做Nagle的算法。该算法是指，发送端即使有要发送的数据，如果很少的话，会延迟发送。如果应用层给TCP传送数据很快的话，就会把两个应用层数据包“粘”在一起，TCP最后只发一个TCP数据包给接收端。

tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

反送方：

当应用程序调用send函数时，应用程序会将数据从应用程序拷贝到操作系统缓存，再由操作系统从缓冲区读取数据并发送出去

接收方：

对方计算机收到数据也是操作系统先收到，至于应用程序何时处理这些数据，操作系统并不清楚，所以同样需要将数据先存储到操作系统的缓冲区中，当应用程序调用recv时，实际上是从操作系统缓冲区中将数据拷贝到应用程序的过程

上述过程对于TCP与UDP都是相同的不同之处在于：

UDP：

UDP在收发数据时是基于数据包的，即一个包一个包的发送，包与包之间有着明确的分界，到达对方操作系统缓冲区后也是一个一个独立的数据包，接收方从操作系统缓冲区中将数据包拷贝到应用程序

这种方式存在的问题：

发送方发送的数据长度每个操作系统会有不同的限制，数据超过限制则无法发送接收方接收数据时如果应用程序的提供的缓存容量小于数据包的长度将造成数据丢失，而缓冲区大小不可能无限大

TCP：

当我们需要传输较大的数据，或需要保证数据完整性时，最简单的方式就是使用TCP协议了，与UDP不同的是，TCP增加了一套校验规则来保证数据的完整性，会将超过TCP包最大长度的数据拆分为多个TCP包，并在传输数据时为每一个TCP数据包指定一个顺序号，接收方在收到TCP数据包后按照顺序将数据包进行重组，重组后的数据全都是二进制数据，且每次收到的二进制数据之间没有明显的分界

基于这种工作机制TCP在三种情况下会发送粘包问题

当单个数据包较小时接收方可能一次性读取了多个包的数据当整体数据较大时接收方可能一次仅读取了一个包的一部分内容另外TCP协议为了提高效率，增加了一种优化机制，会将数据较小且发送间隔较短的数据合并发送，该机制也会导致发送方将两个数据包粘在一起发送

基础解决方案：

首先明确只有TCP会出现粘包问题，之所以粘包是因为接收方不知道一次该接收的数据长度，那如何才能让接收方知道数据的长度呢？

解决方案：在发送数据前先发送数据长度

cmd 服务端：

import socketimport subprocessimport structserver = socket.socket()server.bind(("127.0.0.1",9090))server.listen()while True:client,addr = server.accept()while True:try:#接收客户端命令cmd = client.recv(1024).decode("utf-8")p = subprocess.Popen(cmd,shell=True,stdout=-1,stderr=-1)# data与err_data都是采用的系统编码，windows是GBKdata = p.stdout.read()err_data = p.stderr.read()print("数据长度:%s" % (len(data) + len(err_data)))#计算数据长度length = len(data) + len(err_data)#将int类型的长度转成字节len_data = struct.pack("i",length)# 先发送长度，在发真实数据有可能长度数据和真实数据黏在一起，而接收方不知道长度数据的字节数导致黏包# 解决的方案就是长度信息占的字节数固定死整数转成一个固定长度字节# 先发送长度给客户端 client.send(len_data)# 再发送数据给客户端client.send(data)client.send(err_data)except ConnectionResetError:client.close()print("连接中断......")break

cmd 客户端：

import socketimport structc = socket.socket()c.connect(("127.0.0.1",9090))while True:cmd = input(">>:").strip()c.send(cmd.encode("utf-8"))# 先接收长度，长度固定为4个字节length = c.recv(4)# 转换为整型len_data = struct.unpack("i",length)[0] print("数据长度为%s" % len_data)# 存储已接收数据all_data = b"" # 已接收长度rcv_size = 0# 循环接收直到接收到的长度等于总长度while rcv_size < len_data:data = c.recv(1024)rcv_size += len(data)all_data += dataprint("接收长度%s" % rcv_size)print(all_data.decode("gbk"))

上述方案已经完美解决了粘包问题，但是扩展性不高，例如我们要实现文件上传下载，不光要传输文件数据，还需要传输文件名字，md5值等等，如何能实现呢？

解决方案：

发送端：

先将所有的额外信息打包到一个头中然后先发送头部数据最后发送真实数据

接收端：

接收固定长度的头部长度数据根据长度数据获取头部数据根据头部数据获取真实数据

cmd 服务端：

# 要求：不仅返回命令的结果还要返回执行命令的时间执行时间:/12/26import socketimport subprocessimport structimport datetimeimport jsonserver = socket.socket()server.bind(("127.0.0.1",9090))server.listen()while True:client,addr = server.accept()while True:try:# 接收命令cmd = client.recv(1024).decode("utf-8")p = subprocess.Popen(cmd,shell=True,stdout=-1,stderr=-1)# data与err_data都是采用的系统编码，windows是GBKdata = p.stdout.read()err_data = p.stderr.read()print("数据长度:%s" % (len(data) + len(err_data)))# 计算真实数据长度length = len(data) + len(err_data)# 在发送数据之前发送额外的信息#t = "{执行时间:%s 真实数据长度:%s" % (datetime.datetime.now(),length)# 把要发送的数据先存到字典中t = {}t["time"] = str(datetime.datetime.now())t["size"] = lengtht["filename"] = "a.mp4"t_json = json.dumps(t) # 得到json格式字符串t_data = t_json.encode("utf-8") # 将json转成了字节t_length = struct.pack("i",len(t_data))# 1.先发送额外信息的长度client.send(t_length)# 2.发送额外信息client.send(t_data)# 3.发送真实数据client.send(data)client.send(err_data)except ConnectionResetError:client.close()print("连接中断......")break# 1.发送了真实数据长度 2.发送了额外信息长度 3.发送额外信息 4.发送真实数据

cmd 客户端：

import socketimport structimport jsonc = socket.socket()c.connect(("127.0.0.1",9090))while True:cmd = input(">>>:")if not cmd:print("命令不能为空")continuec.send(cmd.encode("utf-8"))# 1.接收的是额外信息的长度length = c.recv(4)len_data = struct.unpack("i",length)[0] # 转换为整型# 2.接收额外信息t_data = c.recv(len_data)print(t_data.decode("utf-8"))json_dic = json.loads(t_data.decode("utf-8"))print("执行时间:%s" % json_dic["time"])data_size = json_dic["size"] # 得到数据长度all_data = b"" # 存储已接收数据rcv_size = 0 # 已接收长度# 接收真实数据# 循环接收直到接收到的长度等于总长度while rcv_size < data_size:data = c.recv(1024)rcv_size += len(data)all_data += dataprint("接收长度%s" % rcv_size)print(all_data.decode("gbk"))

文件上传下载

服务端：

import socketimport structimport jsonserver = socket.socket()server.bind(("127.0.0.1",9090))server.listen()client,addr = server.accept()f = open("接收到的文件",mode="wb")head_len = client.recv(4)json_len = struct.unpack("i",head_len)[0]json_str = client.recv(json_len).decode("utf-8")head = json.loads(json_str)print(head)recv_size = 0while recv_size < head["size"]:data = client.recv(1024)f.write(data)recv_size += len(data)print("接收完成...")

客户端：

import socketimport osimport jsonimport structc = socket.socket()c.connect(("127.0.0.1",9090))filepath= r"F:\测试.mp4"f = open(filepath,mode="rb")# 在发送数据前先发送报头head = {"size":os.path.getsize(filepath),"filename":"回顾.mp4"}json_data = json.dumps(head).encode("utf-8")json_len = struct.pack("i",len(json_data))c.send(json_len) # 发长度c.send(json_data) # 发报头# 发数据while True:data = f.read(1024)if not data:break# 发送给服务器c.send(data)print("上传完成...")

其他实例：

import json,struct#假设通过客户端上传1T:1073741824000的文件a.txt#为避免粘包,必须自定制报头header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值#为了该报头能传送,需要序列化并且转为byteshead_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度#客户端开始发送conn.send(head_len_bytes) #先发报头的长度,4个bytesconn.send(head_bytes) #再发报头的字节格式conn.sendall(文件内容) #然后发真实内容的字节格式#服务端开始接收head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式header=json.loads(json.dumps(header)) #提取报头#最后根据报头的内容提取真实的数据,比如real_data_len=s.recv(header['file_size'])s.recv(real_data_len)

本内容不代表本网观点和政治立场，如有侵犯你的权益请联系我们处理。

网友评论

网友评论仅供其表达个人看法，并不表明网站立场。