python TCP避免粘包的一种分装

最新推荐文章于 2023-03-03 10:18:51 发布
最新推荐文章于 2023-03-03 10:18:51 发布
阅读量2.3k 收藏
点赞数
分类专栏： python小代码记录 文章标签： python tcp/ip 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43134049/article/details/121703936
版权

总共两个组程序，
第一组为tcp服务端连接一个客户端
第二组为tcp服务端可连接多个客户端（通过线程进行了class分装）
python2，python3 均运行可用，具体解释见参考

避免粘包的核心代码，以下可运行例子，即将len_data 先通过一条tcp信号先发送过来，设置


            # while (len(buf) < len_data and recv_num < self.repeat_num):
            #     buftmp = client.recv(len_data - len(buf))
            #     buf = buf + buftmp
            #     recv_num = recv_num + 1
            #
            # if len(buf) != len_data:
            #     print("客户端应发送长度为" + str(len_data) + "， 实际接收长度为： " + str(len(buf)))
            #     print(buf)
            #     # time.sleep(100)
            #     print("跳过129")
            # else:
            #
            #     if str(buf) != "b''":
            #         if python_version == "2":
            #             original_return_data = buf.encode('hex')
            #         elif python_version == "3":
            #             original_return_data = buf.hex()
            #
            #         print("4444444444444444")
            #         print(len(buf))
            #
            #         print(str(client_addr) +"的地址原数据："+ str(buf) +" ,转换成十六进制: " + str(original_return_data))
            #         ana2.distance_analysis(original_return_data)
            #     else:
            #         pass

一.只分装了服务端，但是只能连接接收一个客户端
server端

#!/usr/bin/env python2.7
#coding:utf-8
# -*- coding: utf-8 -*-

from socket import *
import json
import struct
import time
import threading

class Server_link():
    """用于初始化。tcp服务端"""
    def __init__(self,HOST = '127.0.0.1',PORT = 8081,listen_num = 3):
        self.HOST = HOST
        self.PORT = PORT
        self.listen_num = listen_num
        self.repeat_num = 10 #设置当没有接收到完整数据帧的时候，重复连接的次数
        self.try_num = 10 # 当客户端掉线后，尝试从连的次数，超过该次数没有连接成功，则认为客户端断线


    def start_server(self):
        """开启服务端"""

        self.server = socket(AF_INET, SOCK_STREAM)
        self.server.bind((self.HOST, self.PORT))
        self.server.listen(self.listen_num)
        t_server = threading.Thread(target=self.run)
        t_server.start()

    def run(self):
        """服务端监听程序"""
        while True:
            try_num = 0
            print('等待客户端连接......')  # 等待cilent的连接
            self.client, client_addr = self.server.accept()
            print("成功连接IP：" + str(client_addr) + "的客户端")  # (连接对象，客户端的ip和端口)
            print("\n")

            while True:
                 try:
                      length = self.client.recv(4)
                      len_data = struct.unpack('i', length)
                      len_data = len_data[0]
                      print('接收到的原始长度字符%s:' % length)
                      print('数据长度为%s:' % len_data)

                      buf = self.receive_real(len_data)
                      print("接收到的真实数据为： " + str(buf))

                      json_buf = json.loads(buf)
                      print(type(json_buf))
                      status = json_buf['status']
                      # self.logic_send(status)
                 except:
                      if try_num > self.try_num:
                           print(str(client_addr) + "的客户端连接中断！！！！")
                           break
                      else:
                           try_num = try_num + 1

    def receive_real(self,len_data):
        """接收真实数据"""
        """ len_data 为预先发过来的真实数据长度 """
        buf = b''
        recv_size = 0
        recv_num = 0  # 接收次数

        buf = self.client.recv(len_data)

        while (len(buf) <len_data and recv_num < self.repeat_num ):
            buftmp = self.client.recv(len_data - len(buf))
            buf = buf + buftmp
            recv_num = recv_num + 1

        if len(buf) != len_data:
            print("客户端应发送长度为" + str(len_data) +"， 实际接收长度为： " + str(len(buf))  )
            time.sleep(100)

        return buf




if __name__ == '__main__':
    s = Server_link()
    s.start_server()
    print("开启tcp服务端线程拉起完成")

client 端

#!/usr/bin/env python2.7
#coding:utf-8
# -*- coding: utf-8 -*-


from socket import *
import json
import struct
import time
client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8081))

while True:
#打开发1
     data={"status":"Link_m","dict": None}
     data=json.dumps(data)

     # data = "Head" + data
     length = len(data)

     len_data = struct.pack('i', length)
#固定字节长度，告知数据长度为多少
     client.send(len_data)
     client.send(data.encode('utf-8'))

server端输出：

接收到的真实数据为： {"status": "Link_m", "dict": null}
<type 'dict'>
接收到的原始长度字符"   :
数据长度为34:
接收到的真实数据为： {"status": "Link_m", "dict": null}
<type 'dict'>
接收到的原始长度字符"   :
数据长度为34:
接收到的真实数据为： {"status": "Link_m", "dict": null}
<type 'dict'>
接收到的原始长度字符"   :
数据长度为34:
接收到的真实数据为： {"status": "Link_m", "dict": null}

二.对服务端和客户端都加上了接收和发送的分装线程类的,一个服务端可以对应多个客户端

server端

#!/usr/bin/env python2.7
#coding:utf-8
# -*- coding: utf-8 -*-

from socket import *
import json
import struct
import time
import threading

class Server_link():
    """用于初始化。tcp服务端"""
    def __init__(self,HOST = '127.0.0.1',PORT = 8081,listen_num = 3):
        self.HOST = HOST
        self.PORT = PORT
        self.listen_num = listen_num
        self.repeat_num = 10 #设置当没有接收到完整数据帧的时候，重复连接的次数
        self.try_num = 10 # 当客户端掉线后，尝试从连的次数，超过该次数没有连接成功，则认为客户端断线
        self.client_addr_list = [] # 用于存储连接上的客户端的地址 # client_addr  来自 new_client_socket, client_addr = socket_tcp_server.accept()


    def start_server(self):
        """开启服务端"""

        self.server = socket(AF_INET, SOCK_STREAM)
        self.server.bind((self.HOST, self.PORT))
        self.server.listen(self.listen_num)
        t_server = threading.Thread(target=self.listen_client)
        t_server.start()

    def listen_client(self):
        """客户端监听程序，用于监听客户端的连接"""
        while True:

            print('等待客户端连接......')  # 等待cilent的连接
            self.hint_client_infor()
            client, client_addr = self.server.accept()
            self.link_client(client, client_addr) #成功获得客户端，开启针对于该客户端对应的接收与发送函数

    def hint_client_infor(self,symbol = ""):
        print("当前客户端连接数量： " + str(len(self.client_addr_list)))
        for i in self.client_addr_list:
            print(symbol + str(i))
        print("*" * 100)
        print("\n")

    def link_client(self,client,client_addr):

        self.client_addr_list.append((client,client_addr))
        # t_client_recv = threading.Thread(target=self.client_recv, args=((client,client_addr),))
        # t_client_recv.start()
        t_client_send = threading.Thread(target=self.client_send, args=((client,client_addr),))
        t_client_send.start()
        print("成功连接IP：" + str(client_addr) + "的客户端")  # (连接对象，客户端的ip和端口)
        print("\n")



    def client_recv(self,data):
        client = data[0]
        client_addr = data[1]
        try_num = 0
        while True:
            try:
                length = client.recv(4)
                len_data = struct.unpack('i', length)
                len_data = len_data[0]
                print('接收到的原始长度字符%s:' % length)
                print('数据长度为%s:' % len_data)

                buf = self.receive_real(client,len_data)
                print("接收到的真实数据为： " + str(buf))

                json_buf = json.loads(buf)
                print(type(json_buf))
                status = json_buf['status']

            except:
                if try_num > self.try_num:
                    print(str(client_addr) + "的客户端连接中断！！！！")
                    if data in self.client_addr_list:
                        self.client_addr_list.remove(data)
                    client.close()
                    self.hint_client_infor(symbol="recv: ")

                    break
                else:
                    try_num = try_num + 1

    def client_send(self,data):
        client = data[0]
        client_addr = data[1]
        try_num = 0
        json_data = {"status": "from_server", "dict": None}
        while True:
            try:
                self.send_data(client,json_data)
            except:
                if try_num > self.try_num:
                    print(str(client_addr) + "的客户端连接中断！！！！")
                    if data in self.client_addr_list:
                        self.client_addr_list.remove(data)
                    client.close()
                    self.hint_client_infor(symbol="send: ")
                    break
                else:
                    try_num = try_num + 1



    def receive_real(self,client,len_data):
        """接收真实数据"""
        """ len_data 为预先发过来的真实数据长度 """
        buf = b''
        recv_size = 0
        recv_num = 0  # 接收次数

        buf = client.recv(len_data)

        while (len(buf) <len_data and recv_num < self.repeat_num ):
            buftmp = client.recv(len_data - len(buf))
            buf = buf + buftmp
            recv_num = recv_num + 1

        if len(buf) != len_data:
            print("客户端应发送长度为" + str(len_data) +"， 实际接收长度为： " + str(len(buf))  )
            time.sleep(100)

        return buf

    def send_data(self,client,json_data):
          """用于发送数据"""
          json_data = json.dumps(json_data)

          # data = "Head" + data
          length = len(json_data)

          len_data = struct.pack('i', length)
          # 固定字节长度，告知数据长度为多少
          client.send(len_data)
          client.send(json_data.encode('utf-8'))



if __name__ == '__main__':
    s = Server_link()
    s.start_server()
    print("开启tcp服务端线程拉起完成")

client端

#!/usr/bin/env python2.7
#coding:utf-8
# -*- coding: utf-8 -*-

from socket import *
import json
import struct
import time
import threading

class Client_link():
    """用于初始化。tcp客户端"""
    def __init__(self,HOST = '127.0.0.1',PORT = 8081):
        self.HOST = HOST
        self.PORT = PORT
        self.repeat_num = 10 #设置当没有接收到完整数据帧的时候，重复连接的次数


    def start_client(self):
        """开启客户端"""

        self.client = socket(AF_INET, SOCK_STREAM)
        self.client.connect((self.HOST, self.PORT))
        t_client = threading.Thread(target=self.run)
        t_client.start()

    def run(self):
        """客户端监听程序"""
        while True:
            print('开始连接下位机服务端......')  # 等待cilent的连接
            while True:
                length = self.client.recv(4)
                len_data = struct.unpack('i', length)
                len_data = len_data[0]
                print('接收到的原始长度字符%s:' % length)
                print('数据长度为%s:' % len_data)

                buf = self.receive_real(len_data)
                print("接收到的真实数据为： " + str(buf))

                json_buf = json.loads(buf)
                print(type(json_buf))
                status = json_buf['status']
                #self.logic_send(status)



    def receive_real(self,len_data):
        """接收真实数据"""
        """ len_data 为预先发过来的真实数据长度 """
        buf = b''
        recv_size = 0
        recv_num = 0  # 接收次数

        buf = self.client.recv(len_data)

        while (len(buf) <len_data and recv_num < self.repeat_num ):
            buftmp = self.client.recv(len_data - len(buf))
            buf = buf + buftmp
            recv_num = recv_num + 1

        if len(buf) != len_data:
            print("服务端应发送长度为" + str(len_data) +"， 实际接收长度为： " + str(len(buf))  )
            time.sleep(100)

        return buf

    def send_data(self,data):
          """用于发送数据"""

          data = json.dumps(data)

          # data = "Head" + data
          length = len(data)

          len_data = struct.pack('i', length)
          # 固定字节长度，告知数据长度为多少
          self.client.send(len_data)
          self.client.send(data.encode('utf-8'))





if __name__ == '__main__':
    c = Client_link()
    c.start_client()
    print("开启tcp客户端线程拉起完成")

    # data = {"status": "cscs", "dict": None}
    # while True:
    #      c.send_data(data)
    #      time.sleep(0.5)

服务端连接输出

等待客户端连接......开启tcp服务端线程拉起完成

当前客户端连接数量： 0
****************************************************************************************************


成功连接IP：('127.0.0.1', 55969)的客户端


等待客户端连接......
当前客户端连接数量： 1
(<socket.socket fd=716, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8081), raddr=('127.0.0.1', 55969)>, ('127.0.0.1', 55969))
****************************************************************************************************


('127.0.0.1', 55969)的客户端连接中断！！！！
当前客户端连接数量： 0
****************************************************************************************************


成功连接IP：('127.0.0.1', 55971)的客户端


等待客户端连接......
当前客户端连接数量： 1
(<socket.socket fd=724, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8081), raddr=('127.0.0.1', 55971)>, ('127.0.0.1', 55971))
****************************************************************************************************


成功连接IP：('127.0.0.1', 55972)的客户端


等待客户端连接......
当前客户端连接数量： 2
(<socket.socket fd=724, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8081), raddr=('127.0.0.1', 55971)>, ('127.0.0.1', 55971))
(<socket.socket fd=808, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8081), raddr=('127.0.0.1', 55972)>, ('127.0.0.1', 55972))
****************************************************************************************************

客户端连接输出

数据长度为39:
接收到的真实数据为： {"status": "from_server", "dict": null}
<type 'dict'>
接收到的原始长度字符'   :
数据长度为39:
接收到的真实数据为： {"status": "from_server", "dict": null}
<type 'dict'>
接收到的原始长度字符'   :
数据长度为39:
接收到的真实数据为： {"status": "from_server", "dict": null}
<type 'dict'>
接收到的原始长度字符'   :
数据长度为39:
接收到的真实数据为： {"status": "from_server", "dict": null}
<type 'dict'>
接收到的原始长度字符'   :
数据长度为39:
程序员进化不脱发!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python网络与并发编程 02 TCP粘包
weixin_43422005的博客
07-11 353
TCP/Socket与subprocess 我们准备做一个可以在Client端远程执行Server端的shell命令并拿到其执行结果的程序，而涉及到网络通信就必然会使用到socket模块，此外还需要subprocess模块拿到命令执行结果。 关于传输层协议的选择我们采用TCP协议，因为它是可靠传输协议且一次传输的数据量要比UDP协议更大。 以下是Server端的代码实现： import subprocess from socket import * # 默认直接实例化socket是IPV4 + TCP协议
python发送tcp数据包_TCP数据包分片机制详解
weixin_39637723的博客
12-03 1118
IP分片在以太网上，由于电气限制，一帧不能超过1518字节，除去以太网帧头14字节(mac地址等)和帧尾4字节校验，还剩1500字节，这个大小称为MTU(最大传输单元)。如果你的IP包大于1500字节，IP层就会分片了。而1492的MTU值的来源，是因为PPPoE协议。PPP协议是宽带运营商用于对用户认证计费的(TCP/IP以太网无此功能)。PPPoE头尾一共8字节，所以有效载荷MTU变小了，原来...
python socket实现文件传输（防粘包）
Python热爱者的博客
03-25 610
1.文件传输的要点： 采用iterator(迭代器对象）迭代读取，提高读取以及存取效率； 通过for line in file_handles逐行conn.send()； 2.socket粘包问题: [出现原因]：A.TCP协议为了提高传输效率，发送方往往需要收集定量的数据才会封装给底层并发送，若出现连续send(data)，TCP会把该数据进行整合(直到装满数据缓冲区），这样就造成了粘包数据；B...
Python:（学习记录）解决TCP粘包与分包
zJay-L's Blog
03-03 702
学习记录
python 网络编程 05 socket模块 TCP协议 大型文件的上传 并避免TCP粘包
徐奥雯-ASSETS
07-30 114
服务器端 # 服务器 import socket import json import struct sk = socket.socket() sk.bind(("127.0.0.1", 8080)) # 注意双括号 sk.listen() # 监听 conn, addr = sk.accept() # 等待接受客户端的连接 阻塞等待 返回两个值 b_len_dic = conn.recv(4) # 收四个字节内容 是客户端封装的字典的长度信息 以此让服务器知道接收字典的长度 以避免粘包 len
python3 分装自己的包
OS Developer的博客
02-24 221
python3 分装自己的包
python3 tcp的粘包现象和解决办法解析
12-23
这篇文章主要介绍了python3 tcp的粘包现象和解决办法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 服务器端 import socket sk = socket.socket() sk....
python TCP Socket的粘包和分包的处理详解
09-20
主要介绍了python TCP Socket的粘包和分包的处理详解，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
详解python中TCP协议中的粘包问题
09-19
主要介绍了python中TCP协议中的粘包问题，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
不粘包，会重连的python TCP客户端代码（手打2021.12）
weixin_43134049的博客
12-15 2651
1.通过3个互斥锁与一个布尔变量进行进行管理，避免使用轮询方法，增加cpu占用率 如下： self.mutex_client_link = threading.Lock() self.mutex_client_send = threading.Lock() # 当没有连接接上服务端的时候，通过该锁，使得发送线程阻塞 self.mutex_client_recv = threading.Lock() # 当没有连接接上服务端的时候，通过该锁，使得接受线程阻塞
python gui界面 tcp_python设计tcp数据包协议类的例子
weixin_39518678的博客
11-28 165
一. 问题描述在tcp编程中，最需要解决的就是粘包分包问题。所以，我们需要在每个数据包前面加上数据包的长度用以分割粘连的包。二. 包结构的设计包的组成：包长度+数据域包长度：用4个字节存储数据域长度，数据域长度即为其所占字节数数据域：由若干个变量组成，如果是定长变量则不用加变量长度定长变量：我们人为规定，传输中的int为4字节定长变量变长变量：那就是字符串啦文字难理解，那我就画个图吧：上图的第一行...
Python 网络编程（进阶）：TCP协议、TCP编程
Robin_Pi的博客
12-21 585
Python 网络编程（进阶）TCP协议1. 预备知识分包粘包2. TCP协议2.1 TCP协议的作用分包：TCP传输的“特性”2.2 TCP 数据包的大小2.3 TCP数据包的编号（SEQ）2.4 TCP数据包的组装2.5 慢启动和 ACK2.6 数据包的遗失处理 1. 预备知识 分包 （1）what is 分包 TCP是 以段（Segment）为单位 发送数据的，建立TCP链接后，有一个 最大报文长度（Maximum Segment Size，MSS） ，就是 TCP数据包每次能够传输的最大数据分段。
python tcp处理_python中TCP粘包问题解决方案
weixin_39765625的博客
12-23 872
TCP协议中的粘包问题1.粘包现象基于TCP写一个远程cmd功能#服务端importsocketimportsubprocesssever=socket.socket()sever.bind(('127.0.0.1', 33521))sever.listen()whileTrue:client, address=sever.accept()whileTrue:try:cmd= client.rec...
Python中黏包现象及解决
weixin_56319791的博客
12-04 320
Python中黏包现象 什么是黏包现象 ? 因为TCP是基于数据流的，在服务端与客户端进行数据传输的时候，会自动将一小段一小段的数据打包成一个大分段的数据，然后传输，这样我们接受数据的时候就难以处理我们想要的数据 比如，我们想要在服务端给客户端发送数据，1041 ABCDAE， serve.send(“1041”.encode(“utf8”)) serve.send(“ABCDAE”.encode(“utf8”)) 我们想要在客户端先接受1041这段数据，然后接受ABCDAE client.recv(1
【二十七】Python全栈之路--TCP_UDP_黏包
董坤的博客
12-06 139
文章目录1. tcp协议下的socket使用2. udp协议下的socket使用3. 黏包 1. tcp协议下的socket使用 2. udp协议下的socket使用 3. 黏包
Python基础学习(13)—面向对象2(特殊方法，分装及装饰器)
weixin_45659953的博客
10-25 248
面向对象(2) 1.1 特殊方法(魔术方法) 1 特殊方法例如__init__的都是以__开头__结尾的方法， 特殊方法会在特定的时候自动调用，init会在对象创建以后立即执行并且init会对新创建的对象初始化属性 2 ** self** 对于类中的方法来说，self 参数（第一个参数）代表该构造方法正在初始化的对象，换句话说，Python 会自动绑定类方法的第一个参数指向调用该方法的对象， 打个...
python 分隔列队机制完美解决TCP粘包\分包问题
热门推荐
m0_60394896的博客
05-24 1万+
在套接字中， 由于TCP的机制或者接受最大值(MSS) < 应接收的值,出现粘包,分包现象 (如图1) 解决此问题, 可以将发送的内容转换repr (‘something\n’ -> ‘something\n"’), 并添加分隔符. 解析的时候， 通过分割分隔符， 组成列队Queue, 先出后进. 如果其中有分隔符， 那么其中的内容进入ReadyQueue,如果分割最后无分隔符， 则进入等待WaitKey， 等下次分割出的第一个相结合, 进入ReadyQueue. (如图2)
python串口数据分包_python TCP Socket的粘包和分包的处理详解
weixin_39702799的博客
12-07 979
概述在进行TCP Socket开发时，都需要处理数据包粘包和分包的情况。本文详细讲解解决该问题的步骤。使用的语言是Python。实际上解决该问题很简单，在应用层下，定义一个协议：消息头部+消息长度+消息正文即可。那什么是粘包和分包呢？关于分包和粘包粘包：发送方发送两个字符串”hello”+”world”，接收方却一次性接收到了”helloworld”。分包：发送方发送字符串”helloworld”...
用python写不粘包的tcp服务端程序
最新发布
09-16
我可以为你提供一个简单的python代码示例，用来编写不粘包的tcp服务端程序：import socket# 创建socket对象 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# 绑定本机的IP和端口号 s.bind(('localhost', ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员进化不脱发!

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值