一，发生粘包
服务器端
1 from socket import * 2 phone=socket(AF_INET,SOCK_STREAM) #套接字 3 phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #解决端口占用 4 phone.bind(('127.0.0.1',8080)) #绑定端口和Ip到套接字 5 phone.listen(5) 6 conn,client_addr=phone.accept() #等待tcp接受 7 8 9 # data1=conn.recv(10) 10 # print('data1: ',data1) 11 # data2=conn.recv(4) 12 # print('data2:',data2) 13 #接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分， 14 #服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
客户端
1 from socket import * 2 import time 3 phone=socket(AF_INET,SOCK_STREAM) 4 phone.connect(('127.0.0.1',8080)) 5 6 7 # phone.send('helloworld'.encode('utf-8')) 8 # phone.send('egon'.encode('utf-8')) 9 #发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）
二，用struct模块解决粘包问题
为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据
1 #_*_coding:utf-8_*_ 2 #http://www.cnblogs.com/coser/archive/2011/12/17/2291160.html 3 __author__ = 'Linhaifeng' 4 import struct 5 import binascii 6 import ctypes 7 8 values1 = (1, 'abc'.encode('utf-8'), 2.7) 9 values2 = ('defg'.encode('utf-8'),101) 10 s1 = struct.Struct('I3sf') 11 s2 = struct.Struct('4sI') 12 13 print(s1.size,s2.size) 14 prebuffer=ctypes.create_string_buffer(s1.size+s2.size) 15 print('Before : ',binascii.hexlify(prebuffer)) 16 # t=binascii.hexlify('asdfaf'.encode('utf-8')) 17 # print(t) 18 19 20 s1.pack_into(prebuffer,0,*values1) 21 s2.pack_into(prebuffer,s1.size,*values2) 22 23 print('After pack',binascii.hexlify(prebuffer)) 24 print(s1.unpack_from(prebuffer,0)) 25 print(s2.unpack_from(prebuffer,s1.size)) 26 27 s3=struct.Struct('ii') 28 s3.pack_into(prebuffer,0,123,123) 29 print('After pack',binascii.hexlify(prebuffer)) 30 print(s3.unpack_from(prebuffer,0)) 31 32 关于struct的详细用法
服务器端
1 import socket 2 import subprocess 3 import struct 4 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机 5 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加 6 phone.bind(('127.0.0.1',8088)) #绑定手机卡 7 phone.listen(5) #开机 8 9 print('starting...') 10 while True: #链接循环 11 conn,client_addr=phone.accept() #等电话 （链接，客户的的ip和端口组成的元组） 12 print('-------->',conn,client_addr) 13 14 #收，发消息 15 while True:#通信循环 16 try: 17 cmd=conn.recv(1024) 18 print(cmd) 19 if not cmd:break #针对linux 20 #执行cmd命令，拿到cmd的结果，结果应该是bytes类型 21 #。。。。 22 res = subprocess.Popen(cmd.decode('utf-8'), shell=True, 23 stdout=subprocess.PIPE, 24 stderr=subprocess.PIPE) 25 stdout=res.stdout.read() 26 stderr=res.stderr.read() 27 print(stdout) 28 29 #先发报头(转成固定长度的bytes类型) 30 header = struct.pack('i',len(stdout)+len(stderr)) 31 print(header) 32 conn.send(header) 33 #再发送命令的结果 34 conn.send(stdout) 35 conn.send(stderr) 36 except Exception: 37 break 38 conn.close() #挂电话 39 phone.close() #关机
客户端
1 import socket 2 import struct 3 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机 4 phone.connect(('127.0.0.1',8088)) #绑定手机卡 5 6 #发，收消息 7 while True: 8 cmd=input('>>: ').strip() 9 if not cmd:continue 10 11 phone.send(cmd.encode('utf-8')) 12 #先收报头 13 header_struct=phone.recv(4) 14 print(header_struct) 15 unpack_res = struct.unpack('i', header_struct) 16 total_size=unpack_res[0] 17 print(total_size) 18 19 #再收数据 20 recv_size=0 #10241=10240+1 21 total_data=b'' 22 while recv_size < total_size: 23 recv_data=phone.recv(1024) 24 print(recv_data) 25 recv_size+=len(recv_data) 26 print(recv_size) 27 total_data+=recv_data 28 print(total_data) 29 # else: 30 print(total_data.decode('gbk')) 31 phone.close()
三，大文件粘包问题
服务器端
1 import socket 2 import subprocess 3 import struct 4 import json 5 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机 6 phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加 7 phone.bind(('127.0.0.1',8082)) #绑定手机卡 8 phone.listen(5) #开机 9 10 print('starting...') 11 while True: #链接循环 12 conn,client_addr=phone.accept() #等电话 （链接，客户的的ip和端口组成的元组） 13 print('-------->',conn,client_addr) 14 15 #收，发消息 16 while True:#通信循环 17 try: 18 cmd=conn.recv(1024) 19 if not cmd:break #针对linux 20 #执行cmd命令，拿到cmd的结果，结果应该是bytes类型 21 #。。。。 22 res = subprocess.Popen(cmd.decode('utf-8'), shell=True, 23 stdout=subprocess.PIPE, 24 stderr=subprocess.PIPE) 25 stdout=res.stdout.read() 26 stderr=res.stderr.read() 27 #制作报头 28 header_dic = { 29 'total_size': len(stdout)+len(stderr), 30 'filename': None, 31 'md5': None} 32 33 header_json = json.dumps(header_dic) 34 header_bytes = header_json.encode('utf-8') 35 #发送阶段 36 #先发报头长度 37 conn.send(struct.pack('i',len(header_bytes))) 38 #再发报头 39 conn.send(header_bytes) 40 41 #最后发送命令的结果 42 conn.send(stdout) 43 conn.send(stderr) 44 except Exception: 45 break 46 conn.close() #挂电话 47 phone.close() #关机
客户端
1 import socket 2 import struct 3 import json 4 phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机 5 phone.connect(('127.0.0.1',8082)) #绑定手机卡 6 7 #发，收消息 8 while True: 9 cmd=input('>>: ').strip() 10 if not cmd:continue 11 12 phone.send(cmd.encode('utf-8')) 13 #先收报头的长度 14 header_len=struct.unpack('i',phone.recv(4))[0] 15 16 #再收报头 17 header_bytes=phone.recv(header_len) 18 header_json=header_bytes.decode('utf-8') 19 header_dic=json.loads(header_json) 20 total_size=header_dic['total_size'] 21 22 #最后收数据 23 recv_size=0 #10241=10240+1 24 total_data=b'' 25 while recv_size < total_size: 26 recv_data=phone.recv(1024) 27 recv_size+=len(recv_data) 28 total_data+=recv_data 29 print(total_data.decode('gbk')) 30 phone.close()
四，udp套接字
服务器端
1 from socket import * 2 udp_server=socket(AF_INET,SOCK_DGRAM) 3 udp_server.bind(('127.0.0.1',8088)) 4 5 while True: 6 msg,client_addr=udp_server.recvfrom(1024) 7 print('has recv %s' %msg) 8 udp_server.sendto(msg.upper(),client_addr) 9 print('has send') 10 udp_server.close()
客户端
1 from socket import * 2 udp_client=socket(AF_INET,SOCK_DGRAM) 3 4 while True: 5 msg=input('>>: ').strip() 6 udp_client.sendto(msg.encode('utf-8'),('127.0.0.1',8088)) 7 print('has send') 8 # res,server_addr=udp_client.recvfrom(1024) 9 # print('====>',res.decode('utf-8')) 10 11 udp_client.close()
udp 套接字不会发生粘包
服务器端
1 from socket import * 2 udp_server=socket(AF_INET,SOCK_DGRAM) 3 udp_server.bind(('127.0.0.1',8089)) 4 5 msg1,client_addr=udp_server.recvfrom(5) 6 print(msg1) 7 8 msg2,client_addr=udp_server.recvfrom(5) 9 print(msg2)
客户端
1 from socket import * 2 udp_client=socket(AF_INET,SOCK_DGRAM) 3 4 udp_client.sendto('hello'.encode('utf-8'),('127.0.0.1',8089)) 5 udp_client.sendto('world'.encode('utf-8'),('127.0.0.1',8089))
五，socketserver套接字
封装了socket，而且解决了Io阻塞问题
服务端
1 # socketserver模块多进程，多线程 2 # 无论你开什么都是开线程，线程就有IO，这个模块帮你解决这个IO问题 3 4 # 基础版本，遇到问题，不能无限开线程，而且没有解决IO 5 # 线程开启跟进程开启一样 6 from socket import * 7 from threading import Thread 8 # s=socket(AF_INET,SOCK_STREAM) 9 # s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加 10 # s.bind(('127.0.0.1',8090)) 11 # s.listen(5) 12 # def talk(conn,addr): 13 # while True: #通信循环 14 # try: 15 # data=conn.recv(1024) 16 # if not data:break 17 # conn.send(data.upper()) 18 # except Exception: 19 # break 20 # conn.close() 21 # if __name__ == '__main__': 22 # while True:#链接循环 23 # conn,addr=s.accept() 24 # p = Thread(target=talk,args=(conn,addr)) 25 # p.start() 26 # s.close() 27 28 # socketserver模块套接字，自动处理IO问题 29 import socketserver 30 class MyTCPhandler(socketserver.BaseRequestHandler): #必须继承这个类 31 def handle(self): 32 # print(self.request) 打印出来的就是conn 33 # print(self.client_address) 打印出来的就是addr 34 while True: 35 try: 36 data=self.request.recv(1024) 37 if not data:break 38 self.request.send(data.upper()) 39 except Exception: 40 break 41 self.request.close() 42 if __name__ == '__main__': 43 server=socketserver.ThreadingTCPServer(('127.0.0.1',8082),MyTCPhandler) #多线程 44 # 三个参数，IP，端口，类 45 # server=socketserver.ForkingTCPServer(('127.0.0.1',8082),MyTCPhandler) #多进程 46 server.allow_reuse_address=True #重用地址 47 server.serve_forever() #永远运行，就是一直开着，相当于while True
客户端
1 from socket import * 2 client=socket(AF_INET,SOCK_STREAM) 3 client.connect(('127.0.0.1',8082)) 4 5 while True: 6 msg=input('>>: ').strip() 7 if not msg:continue 8 client.send(msg.encode('utf-8')) 9 data=client.recv(1024) 10 print(data.decode("utf-8"))