python开发socket套接字：粘包问题&udp套接字&socketserver

一，发生粘包

服务器端

 from socket import *

 phone=socket(AF_INET,SOCK_STREAM)        #套接字

 phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)   #解决端口占用

 phone.bind(('127.0.0.1',8080))   #绑定端口和Ip到套接字

 phone.listen(5)

 conn,client_addr=phone.accept()   #等待tcp接受

 # data1=conn.recv(10)

 # print('data1: ',data1)

 # data2=conn.recv(4)

 # print('data2:',data2)

 #接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，

 #服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

客户端

 from socket import *

 import time

 phone=socket(AF_INET,SOCK_STREAM)

 phone.connect(('127.0.0.1',8080))

 # phone.send('helloworld'.encode('utf-8'))

 # phone.send('egon'.encode('utf-8'))

 #发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

二，用struct模块解决粘包问题

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据

 #_*_coding:utf-8_*_

 #http://www.cnblogs.com/coser/archive/2011/12/17/2291160.html

 __author__ = 'Linhaifeng'

 import struct

 import binascii

 import ctypes

 values1 = (1, 'abc'.encode('utf-8'), 2.7)

 values2 = ('defg'.encode('utf-8'),101)

 s1 = struct.Struct('I3sf')

 s2 = struct.Struct('4sI')

 print(s1.size,s2.size)

 prebuffer=ctypes.create_string_buffer(s1.size+s2.size)

 print('Before : ',binascii.hexlify(prebuffer))

 # t=binascii.hexlify('asdfaf'.encode('utf-8'))

 # print(t)

 s1.pack_into(prebuffer,0,*values1)

 s2.pack_into(prebuffer,s1.size,*values2)

 print('After pack',binascii.hexlify(prebuffer))

 print(s1.unpack_from(prebuffer,0))

 print(s2.unpack_from(prebuffer,s1.size))

 s3=struct.Struct('ii')

 s3.pack_into(prebuffer,0,123,123)

 print('After pack',binascii.hexlify(prebuffer))

 print(s3.unpack_from(prebuffer,0))

 关于struct的详细用法

服务器端

 import socket

 import subprocess

 import struct

 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机

 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加

 phone.bind(('127.0.0.1',8088)) #绑定手机卡

 phone.listen(5) #开机

 print('starting...')

 while True: #链接循环

     conn,client_addr=phone.accept() #等电话 （链接，客户的的ip和端口组成的元组）

     print('-------->',conn,client_addr)

     #收，发消息

     while True:#通信循环

         try:

             cmd=conn.recv(1024)

             print(cmd)

             if not cmd:break #针对linux

             #执行cmd命令，拿到cmd的结果，结果应该是bytes类型

             #。。。。

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

                                    stdout=subprocess.PIPE,

                                    stderr=subprocess.PIPE)

             stdout=res.stdout.read()

             stderr=res.stderr.read()

             print(stdout)

             #先发报头(转成固定长度的bytes类型)

             header = struct.pack('i',len(stdout)+len(stderr))

             print(header)

             conn.send(header)

             #再发送命令的结果

             conn.send(stdout)

             conn.send(stderr)

         except Exception:

             break

     conn.close() #挂电话

 phone.close() #关机

客户端

 import socket

 import struct

 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机

 phone.connect(('127.0.0.1',8088)) #绑定手机卡

 #发，收消息

 while True:

     cmd=input('>>: ').strip()

     if not cmd:continue

     phone.send(cmd.encode('utf-8'))

     #先收报头

     header_struct=phone.recv(4)

     print(header_struct)

     unpack_res = struct.unpack('i', header_struct)

     total_size=unpack_res[0]

     print(total_size)

     #再收数据

     recv_size=0 #10241=10240+1

     total_data=b''

     while recv_size < total_size:

         recv_data=phone.recv(1024)

         print(recv_data)

         recv_size+=len(recv_data)

         print(recv_size)

         total_data+=recv_data

         print(total_data)

     # else:

     print(total_data.decode('gbk'))

 phone.close()

三，大文件粘包问题

服务器端

 import socket

 import subprocess

 import struct

 import json

 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机

 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加

 phone.bind(('127.0.0.1',8082)) #绑定手机卡

 phone.listen(5) #开机

 print('starting...')

 while True: #链接循环

     conn,client_addr=phone.accept() #等电话 （链接，客户的的ip和端口组成的元组）

     print('-------->',conn,client_addr)

     #收，发消息

     while True:#通信循环

         try:

             cmd=conn.recv(1024)

             if not cmd:break #针对linux

             #执行cmd命令，拿到cmd的结果，结果应该是bytes类型

             #。。。。

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

                                    stdout=subprocess.PIPE,

                                    stderr=subprocess.PIPE)

             stdout=res.stdout.read()

             stderr=res.stderr.read()

             #制作报头

             header_dic = {

                 'total_size': len(stdout)+len(stderr),

                 'filename': None,

                 'md5': None}

             header_json = json.dumps(header_dic)

             header_bytes = header_json.encode('utf-8')

             #发送阶段

             #先发报头长度

             conn.send(struct.pack('i',len(header_bytes)))

             #再发报头

             conn.send(header_bytes)

             #最后发送命令的结果

             conn.send(stdout)

             conn.send(stderr)

         except Exception:

             break

     conn.close() #挂电话

 phone.close() #关机

客户端

 import socket

 import struct

 import json

 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机

 phone.connect(('127.0.0.1',8082)) #绑定手机卡

 #发，收消息

 while True:

     cmd=input('>>: ').strip()

     if not cmd:continue

     phone.send(cmd.encode('utf-8'))

     #先收报头的长度

     header_len=struct.unpack('i',phone.recv(4))[0]

     #再收报头

     header_bytes=phone.recv(header_len)

     header_json=header_bytes.decode('utf-8')

     header_dic=json.loads(header_json)

     total_size=header_dic['total_size']

     #最后收数据

     recv_size=0 #10241=10240+1

     total_data=b''

     while recv_size < total_size:

         recv_data=phone.recv(1024)

         recv_size+=len(recv_data)

         total_data+=recv_data

     print(total_data.decode('gbk'))

 phone.close()

四，udp套接字

服务器端

 from socket import *

 udp_server=socket(AF_INET,SOCK_DGRAM)

 udp_server.bind(('127.0.0.1',8088))

 while True:

     msg,client_addr=udp_server.recvfrom(1024)

     print('has recv %s' %msg)

     udp_server.sendto(msg.upper(),client_addr)

     print('has send')

 udp_server.close()

客户端

 from socket import *

 udp_client=socket(AF_INET,SOCK_DGRAM)

 while True:

     msg=input('>>: ').strip()

     udp_client.sendto(msg.encode('utf-8'),('127.0.0.1',8088))

     print('has send')

     # res,server_addr=udp_client.recvfrom(1024)

     # print('====>',res.decode('utf-8'))

 udp_client.close()

udp 套接字不会发生粘包

服务器端

 from socket import *

 udp_server=socket(AF_INET,SOCK_DGRAM)

 udp_server.bind(('127.0.0.1',8089))

 msg1,client_addr=udp_server.recvfrom(5)

 print(msg1)

 msg2,client_addr=udp_server.recvfrom(5)

 print(msg2)

客户端

 from socket import *

 udp_client=socket(AF_INET,SOCK_DGRAM)

 udp_client.sendto('hello'.encode('utf-8'),('127.0.0.1',8089))

 udp_client.sendto('world'.encode('utf-8'),('127.0.0.1',8089))

五，socketserver套接字

封装了socket，而且解决了Io阻塞问题

服务端

 # socketserver模块多进程，多线程

 # 无论你开什么都是开线程，线程就有IO，这个模块帮你解决这个IO问题

 # 基础版本，遇到问题，不能无限开线程，而且没有解决IO

 # 线程开启跟进程开启一样

 from socket import *

 from threading import Thread

 # s=socket(AF_INET,SOCK_STREAM)

 # s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加

 # s.bind(('127.0.0.1',8090))

 # s.listen(5)

 # def talk(conn,addr):

 #     while True: #通信循环

 #         try:

 #             data=conn.recv(1024)

 #             if not data:break

 #             conn.send(data.upper())

 #         except Exception:

 #             break

 #     conn.close()

 # if __name__ == '__main__':

 #     while True:#链接循环

 #         conn,addr=s.accept()

 #         p = Thread(target=talk,args=(conn,addr))

 #         p.start()

 #     s.close()

 # socketserver模块套接字，自动处理IO问题

 import socketserver

 class MyTCPhandler(socketserver.BaseRequestHandler):  #必须继承这个类

     def handle(self):

         # print(self.request)  打印出来的就是conn

         # print(self.client_address)   打印出来的就是addr

         while True:

             try:

                 data=self.request.recv(1024)

                 if not data:break

                 self.request.send(data.upper())

             except Exception:

                 break

         self.request.close()

 if __name__ == '__main__':

     server=socketserver.ThreadingTCPServer(('127.0.0.1',8082),MyTCPhandler)  #多线程

     # 三个参数，IP，端口，类

     # server=socketserver.ForkingTCPServer(('127.0.0.1',8082),MyTCPhandler)  #多进程

     server.allow_reuse_address=True   #重用地址

     server.serve_forever()   #永远运行，就是一直开着，相当于while True

客户端

 from socket import *

 client=socket(AF_INET,SOCK_STREAM)

 client.connect(('127.0.0.1',8082))

 while True:

     msg=input('>>: ').strip()

     if not msg:continue

     client.send(msg.encode('utf-8'))

     data=client.recv(1024)

     print(data.decode("utf-8"))

巴特西

python开发socket套接字：粘包问题&udp套接字&socketserver

一，发生粘包

二，用struct模块解决粘包问题

三，大文件粘包问题

五，socketserver套接字

最新文章

热门文章