粘包现象：
如上篇博客中最后的示例，客户端有个 phone.recv(2014) ， 当服务端发送给客户端的数据大于1024个字节时， 多于1024的数据就会残留在管道中，下次客户端再给服务端发命令时，残留在管道的数据会先发送给客户端，新命令产生的数据会排在上次命令残留数据的后面发送到客户端，即两次结果的数据粘在一起了， 这个就是粘包现象。
粘包现象的原理分析：
# 运行一个软件或程序需要的硬件：CPU、内存、硬盘
# CPU负责执行；CPU执行需要数据，而数据从内存中取，最后可以把数据存到硬盘（内存速度会比硬盘快很多）
# 操作系统所占的内存空间和应用程序所占的内存空间互相隔离 # 客户端的 phone.send(数据) send是应用软件的代码，是发送给操作系统的命令，应用软件先把要发送的数据copy给操作系统的内存然后让操作系统把该数据发送出去
# 应用软件把数据复制给操作系统后，操作系统怎么发这个数据应用软件控制不了
# recv的完成需要2步：1.recv对应的操作系统等待接收对方传过来的数据；（耗时长）；2.recv的操作系统将接收的数据复制给应用软件（耗时短，因为是本地copy）
# send的完成只需要1步： 将数据从自己（应用软件）的内存空间复制到操作系统的内存空间。 # send和recv对比
# 1. 不管是recv还是send都不是在直接接收对方的数据，而是在操作自己的操作系统内存---> so，不是一个send就要对应一个recv
# 2. recv：
# wait data 耗时非常长
# copy data
# send：
# copy data
# 3. TCP协议的特点：发送端为了将多个发往接收端的包能有效的发到对方，会将多次间隔较小且数据量小的数据，合并成一个大的数据包，然后进行封装；这样接收端就难以分辨出来了，即面向流的通信是无消息保护边界的。
粘包解决方法普通版（制作自己的“报头”）：
补充知识点struct模块：
import struct # 制作报头
res = struct.pack("i",123498654) # 输出结果是bytes格式 # i 代表整型，如果是整型，res这个bytes就是固定长度4（跟后面整数具体的大小无关）； #有两个参数：第一个是格式（"i"代表整型），第二个是值
print(res,type(res),len(res))
"""
struct.pack可用于制作报头，把描述信息传入第二个参数value
"""
# 打印结果
# b'\x9ep\\\x07' <class 'bytes'> 4 # 解析报头
unpack_res = struct.unpack("i",res) # 对res这个bytes格式的字符串进行解包 # 解包结果为元祖形式 # 也有两个参数： 1. 格式（"i"） 2. bytes格式的字符串
print(unpack_res) # 打印结果
# (123498654,)
粘包解决方法普通版客户端代码如下：
import socket
import struct client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(("127.0.0.1",9901))
while True:
# 1. 发命令
cmd = input(">>>").strip()
if not cmd:continue
client.send(cmd.encode("utf-8")) # 2. 拿到命令结果并打印
# 第一步：先收“报头”
head = client.recv(4) # head为bytes格式； # 由于报头的长度固定为4，所以recv应该为4
# 第二步：从报头解析出对真实数据的描述信息（真实数据的长度）
total_size = struct.unpack("i",head)[0] # 对head这个报头解析 # struct.unpack()的结果是元祖的形式 # 第三步：接收真实的数据
"""开始循环接收服务端发来的真实数据"""
recv_size = 0 # 用于计算接收到的bytes数
total_recv_res = b"" # 设置一个bytes格式的空字符串，用于拼接、接收服务端发来的真实数据
while recv_size < total_size: # 已经接收的bytes数小于服务端发送的全部字节数
recv_res = client.recv(1024)
total_recv_res += recv_res # 把每次从服务端接收到的真实数据添加到total_recv_res 里面
recv_size += len(recv_res) # 每次从服务端接收到的数据的bytes数加到 recv_size里面； 不要用 recv_size += 1024，这种方法不能准确计算出bytes数
print(total_recv_res.decode("gbk")) phone.close()
服务端代码：
import subprocess
import struct
import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
phone.bind(("127.0.0.1",9901))
phone.listen(5) while True:
conn,client_addr = phone.accept() while True:
try:
# 1. 收命令
cmd = conn.recv(1024) # 2. 执行命令，拿到结果
obj = subprocess.Popen(cmd.decode("utf-8"), shell=True, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout = obj.stdout.read()
stderr = obj.stderr.read() # 3. 把命令结果返回给客户端
# 第一步：制定固定长度的“报头”（报头一定需要是固定长度）
head = struct.pack("i",len(stdout)+len(stderr)) # head 是bytes格式，长度固定为4 # 第二步： 把报头发送给客户端
conn.send(head) # 第三步：再发送真实的结果数据
# conn.send(stdout+stderr) 解决的方法如下所示：
conn.send(stdout)
conn.send(stderr) # 不需要再用“+”，因为这种形式的发送TCP协议就会把数据粘在一起
except ConnectionResetError:
break conn.close()
phone.close()
粘包解决最终版（利用字典制作自己的报头）
服务端代码：
import socket
import subprocess
import json
import struct server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind(("127.0.0.1",8080))
server.listen(5) while True:
conn,addr = server.accept() while True:
try:
# 1. 收命令
cmd = conn.recv(1024) # 2. 处理命令
obj = subprocess.Popen(cmd.decode("utf-8"),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
stdout = obj.stdout.read() # bytes格式
stderr = obj.stderr.read() # 3. 把处理结果发送给客户端
"""
报头应该包含多种信息，而不只是只包含真实信息的长度，所以考虑利用字典去制定报头
"""
# 3.1 用字典形式制作报头
header_dict = {
"filename":"cmd处理",
"md5":"xxxxxx",
"total_size":len(stdout)+len(stderr)
} # 字典不能用于send()，只有bytes才可以
header_json = json.dumps(header_dict) # 将报头字典转化成json格式的字符串
header_bytes = header_json.encode("utf-8") # 将json形式的字符串转化成bytes格式
"""
字典是报头，报头转化成bytes之后你并不能确定bytes的个数，但报头又需要是固定长度，
所以先把head_bytes（报头的bytes格式）的长度利用struct模块打包成固定长度发送给客户端，然后再把header_bytes发送给客户端，
对应的，客户端先收报头长度，然后再接收报头长度个数的bytes，那么客户端第二次接收的bytes就是报头的完整信息
"""
# 3.2 发送报头bytes的长度
header_length = struct.pack("i",len(header_bytes)) # 把报头bytes的个数利用struct.pack（）打包、制定成固定长度（4）
conn.send(header_length)
# 3.3 发送报头bytes的真实信息
conn.send(header_bytes)
# 3.4 发送处理结果的真实数据
conn.send(stdout)
conn.send(stderr)
except ConnectionResetError:
break
conn.close()
server.close()
客户端代码：
import socket
import json
import struct client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(("127.0.0.1",8080)) while True:
cmd = input(">>>").strip()
if not cmd: continue
client.send(cmd.encode("utf-8")) # 1. 接收报头的长度
obj_contain_length = client.recv(4) # 因为报头bytes的长度已经经过struct.pack()的打包，长度固定为4
header_bytes_length = struct.unpack("i",obj_contain_length)[0] # 报头bytes的长度
# 2. 接收报头的数据
header_bytes = client.recv(header_bytes_length) # 接收报头bytes个数的bytes数，就是完整的报头bytes信息
header_json = header_bytes.decode("utf-8") # 将bytes格式解码成json字符串格式
header_dict = json.loads(header_json) # 将报头的json字符串格式反序列化得到报头的字典形式
total_size = header_dict.get("total_size") # 得到报头字典里的处理结果的bytes数
# 3. 接收处理结果的数据
recv_size = 0
total_recv_bytes = b""
while recv_size < total_size:
recv_bytes = client.recv(1024)
total_recv_bytes += recv_bytes
recv_size += len(recv_bytes) print(total_recv_bytes.decode("gbk")) client.close()
文件传输功能：
文件的目录结构如下：
服务端代码：
import socket
import json
import struct
import os
import sys BASE_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.append(BASE_DIR) server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind(("127.0.0.1",8089))
server.listen(5) while True:
conn,addr = server.accept() while True:
try:
# 1. 收命令
res = conn.recv(1024) # b"get a.txt" # 2. 解析命令，提取相应命令参数
cmd,file_name = res.decode("utf-8").split() # ["get","a.txt"] # 3. 以读的模式打开文件，读取文件内容发送给客户端
# 第一步：用字典形式制作报头
file = os.path.join(BASE_DIR,"share",file_name)
header_dict = {
"filename":file_name,
"md5":"xxxxxx",
"total_size": os.path.getsize(file)
}
header_json = json.dumps(header_dict)
header_bytes = header_json.encode("utf-8") # 第二步：发送报头bytes的长度
header_length = struct.pack("i",len(header_bytes))
conn.send(header_length)
# 第三步：发送报头bytes的真实信息
conn.send(header_bytes) # 4. 发送处理结果的真实数据
with open(file,"rb") as f:
for line in f:
conn.send(line) # 单行发送跟一下全部发送效果上没有区别，因为单行发送也是粘在一起 except ConnectionResetError:
break
conn.close()
server.close()
客户端代码：
import socket
import json
import struct
import os,sys BASE_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.append(BASE_DIR) client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(("127.0.0.1",8089)) while True:
# 1. 发命令
cmd = input(">>>").strip()
if not cmd: continue
client.send(cmd.encode("utf-8")) # 2. 以写的模式打开一个新文件，把服务端发来的文件内容写入新文件
# 第一步： 接收报头的长度
obj_contain_length = client.recv(4)
header_bytes_length = struct.unpack("i",obj_contain_length)[0]
# 第二步：再收报头，从报头中解析出对真实信息的描述信息
header_bytes = client.recv(header_bytes_length)
header_json = header_bytes.decode("utf-8")
header_dict = json.loads(header_json)
total_size = header_dict.get("total_size")
file_name = header_dict["filename"]
# 3. 接收真实的数据
with open(os.path.join(BASE_DIR,"download",file_name),"wb") as f:
recv_size = 0
while recv_size < total_size:
line = client.recv(1024)
f.write(line)
recv_size += len(line)
print("文件总大小：%s；已下载：%s；已下载比例：%s"%(total_size,recv_size,(recv_size/total_size))) client.close()
文件传输功能函数版：
客户端代码：
import socket
import json
import struct
import os,sys BASE_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.append(BASE_DIR) """下载功能：即从服务端接收文件"""
def get(client,cmd):
# 2. 以写的模式打开一个新文件，把服务端发来的文件内容写入新文件
# 第一步： 接收报头的长度
file_name = cmd[1]
obj_contain_length = client.recv(4)
header_bytes_length = struct.unpack("i", obj_contain_length)[0]
# 第二步：再收报头，从报头中解析出对真实信息的描述信息
header_bytes = client.recv(header_bytes_length)
header_json = header_bytes.decode("utf-8")
header_dict = json.loads(header_json)
total_size = header_dict.get("total_size")
# file_name = header_dict["filename"]
# 3. 接收真实的数据
with open(os.path.join(BASE_DIR, "download", file_name), "wb") as f:
recv_size = 0
while recv_size < total_size:
line = client.recv(1024)
f.write(line)
recv_size += len(line)
print("文件总大小：%s；已下载：%s；已下载比例：%s" % (total_size, recv_size, (recv_size / total_size))) """上传功能：即发送文件给服务端"""
def put(client,cmd):
file_name = cmd[1]
file = os.path.join(BASE_DIR,"download",file_name)
# 1. 制定报头
file_size = os.path.getsize(file)
head_dict ={
"filename":file_name,
"dm5": "xxxxxxx",
"total_size":file_size
}
head_json = json.dumps(head_dict)
head_bytes = head_json.encode("utf-8")
# 2. 发送报头
head_bytes_length = struct.pack("i",len(head_bytes))
client.send(head_bytes_length)
client.send(head_bytes)
# 3. 发送真实数据
with open(file,"rb") as f:
send_size = 0
for line in f:
client.send(line)
send_size += len(line)
print("文件总大小：%s；已上传：%s；上传比例：%s"%(file_size,send_size,(send_size/file_size))) def run():
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(("127.0.0.1",8089)) while True:
# 1. 发命令
cmd = input(">>>").strip()
if not cmd: continue
client.send(cmd.encode("utf-8"))
cmd_list = cmd.split()
cmd_dict = {
"get":get,
"put":put
}
for k,v in cmd_dict.items():
if cmd_list[0] == k:
v(client,cmd_list) client.close() if __name__ == "__main__":
run()
服务端代码：
import socket
import json
import struct
import os
import sys BASE_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.append(BASE_DIR) """下载功能：即发送数据给客户端"""
def get(conn,cmd):
file_name = cmd[1]
file = os.path.join(BASE_DIR, "share", file_name)
header_dict = {
"filename": file_name,
"md5": "xxxxxx",
"total_size": os.path.getsize(file)
}
header_json = json.dumps(header_dict)
header_bytes = header_json.encode("utf-8") header_length = struct.pack("i", len(header_bytes))
conn.send(header_length)
conn.send(header_bytes) # 发送处理结果的真实数据
with open(file, "rb") as f:
for line in f:
conn.send(line) """上传功能：即接收客户端发来的数据"""
def put(conn,cmd):
file_name = cmd[1]
# 1. 先接收报头长度
bytes_header_length = conn.recv(4)
header_length = struct.unpack("i",bytes_header_length)[0]
# 2. 接收报头数据
header_bytes = conn.recv(header_length) # bytes格式的字符串
header_json = header_bytes.decode("utf-8")
header = json.loads(header_json)
total_size = header["total_size"] # 要上传数据的总大小
# 3. 接收真实的数据
with open(os.path.join(BASE_DIR,"share",file_name),"wb") as f:
recv_size = 0
while recv_size < total_size:
recv_bytes = conn.recv(1024)
f.write(recv_bytes)
recv_size += len(recv_bytes) def run():
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind(("127.0.0.1",8089))
server.listen(5) while True:
conn,addr = server.accept() while True:
try:
# 1. 收命令
res = conn.recv(1024) # b"get a.txt"
# 2. 解析命令，提取相应命令参数
cmd = res.decode("utf-8").split() # ["get","a.txt"] cmd_dict = {
"get": get,
"put": put
}
for k,v in cmd_dict.items():
if cmd[0] == k:
v(conn,cmd) except ConnectionResetError:
break
conn.close()
server.close() if __name__ == "__main__":
run()
基于UDP协议的套接字：
客户端代码：
from socket import * client = socket(AF_INET,SOCK_DGRAM) """
UTP不需要建链接（通道）。所以不需要 connect
""" while True:
msg = input(">>>").strip()
client.sendto(msg.encode("utf-8"),("127.0.0.1",8080)) # sendto传入两个参数：数据和接收端的IP和端口 # msg也是bytes格式 data = client.recvfrom(1024)
print(data) client.close() # 运行结果：
# (b'HELLO', ('127.0.0.1', 8080)) """
UTP协议不会粘包
UTP协议能够发送空消息，所以不需要写 if not msg: continue
UTP协议一定是一个sendto对应一个 recvfrom
对于recvfrom(1024)，在Windows上，如果接收的数据大于1024个bytes，会报错；在Linux上，如果接收的数据大于1024个bytes，程序只接收1024个，多余的数据就丢失了
"""
客户端代码：
from socket import * # 导入socket模块时可以利用 import * server = socket(AF_INET,SOCK_DGRAM) # DGRAM 是UDP协议，即“数据报协议”
server.bind(("127.0.0.1",8080)) # UDP协议也需要bind """
UTP协议没有 listen和accept；因为UTP不需要建通道，而TCP中的listen和accept是为了建通道
"""
while True:
data,addr = server.recvfrom(1) # 接收数据；收到的也是bytes格式 # 接收到的数据是元祖形式：第一个元素是数据信息，第二个是发送端的IP和端口 # 数据信息也是bytes格式
print(data,addr) server.sendto(data.upper(),addr) # recvfrom中包含发送端的IP和端口，还通过这个IP端口发发送端回数据
server.close() # 运行结果：
# b'hello' ('127.0.0.1', 53729)