当前位置： 移动技术网 > IT编程>脚本编程>Python > socket,socketserver,tcp黏包问题,网络编程

socket,socketserver,tcp黏包问题,网络编程

2019年06月19日  | 移动技术网IT编程  | 我要评论

侍从官之肩在哪,管野亚丽莎,诺安基金大厦

1,socket的使用

  1. 基于tcp的socket的使用
    tcp是有链接，面向流的，客户端和服务端一旦连接，不在断开的时候是不会断的
    简单使用
     1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/13 19:36
 4 # @author   : aolishuai
 5 # @file     : 服务端
 6 
 7 import socket
 8 
 9 #创建一个socket对象
10 server = socket.socket()#创建一个手机
11 
12 ip_port = ('192.168.1.9',8001)#创建一张电话卡
13 
14 server.bind(ip_port)#插上电话卡
15 
16 #监听ip地址和端口
17 server.listen()#开机,listen(10)后面可以有10人等待，超过10人，直接让超过的人数去掉
18 
19 
20 print(1111)
21 #等待客户端的连接
22 conn, addr =server.accept()
23 #接收消息
24 from_client_msg=conn.recv(1024)#单位大小为b，1kb=1024b
25 #消息字符转换并打印
26 print(from_client_msg.decode('utf-8'))
27 #消息发给客户端
28 conn.send("勇士说的".encode('utf-8'))
29 
30 #消息发完断开连接,
31 conn.close()
32 #服务端关机
33 server.close()
     1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/13 19:36
 4 # @author   : aolishuai
 5 # @file     : 客户端
 6 import socket
 7 client = socket.socket()
 8 #拿到服务端ip和端口
 9 server_ip_port = ('192.168.1.9',8001)
10 #连接服务端
11 client.connect(server_ip_port)
12 #发消息
13 client.send("kd断了".encode('utf-8'))
14 
15 from_server_msg=client.recv(1024)
16 from_server_msg=from_server_msg.decode("utf-8")
17 print(from_server_msg)
18 
19 #客户端关闭
20 client.close()

     

  2. udp是没有连接，服务端只能在接收客户端发过来的消息获取到客户端的地址之后，才能返回消息
     1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/14 15:51
 4 # @author   : aolishuai
 5 # @file     : server
 6 
 7 import socket
 8 
 9 sk = socket.socket(type=socket.sock_dgram)
10 sk.bind(('127.0.0.1',8081))
11 
12 msg,addr = sk.recvfrom(1024)
13 print(msg.decode('utf-8'))
14 sk.sendto(b'hihao',addr)
15 
16 sk.close()
     1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/14 15:51
 4 # @author   : aolishuai
 5 # @file     : client
 6 import socket
 7 sk = socket.socket(type=socket.sock_dgram)
 8 ip_port=('127.0.0.1',8081)
 9 
10 sk.sendto(b'hi',ip_port)
11 msg,addr=sk.recvfrom(1024)
12 print(msg.decode('utf-8'))
13 sk.close()

    简单的udpsock使用，服务端是一个时间服务器，在客户端需要发送的时候，发送对应格式的时间

     1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/14 16:18
 4 # @author   : aolishuai
 5 # @file     : time_server
 6 import socket,time
 7 
 8 sk = socket.socket(type=socket.sock_dgram)
 9 ip_port=('127.0.0.1',8082)
10 
11 sk.bind(ip_port)
12 
13 while true:
14     msg,addr = sk.recvfrom(1024)
15     msg=msg.decode('utf-8')
16     print(msg)
17     t =time.localtime(time.time())
18     give_t = time.strftime(msg,t)
19     sk.sendto(give_t.encode('utf-8'),addr)
20 
21 sk.close()

　　　　

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/14 16:18
 4 # @author   : aolishuai
 5 # @file     : time_client
 6 
 7 import socket
 8 
 9 sk = socket.socket(type=socket.sock_dgram)
10 ip_port=('127.0.0.1',8082)
11 while true:
12     geshi = input('请输入时间格式:').encode('utf-8')
13     sk.sendto(geshi,ip_port)
14     msg,addr = sk.recvfrom(1024)
15     msg= msg.decode('utf-8')
16     print('时间是{0}'.format(msg))
17 sk.close()

 

    1. 黏包问题
      黏包问题：
          tcp协议在进行socket传输的时候，
          1，不知道包有多大，接收的时候可能分多次接收
          2，连续传递小数据包，自身优化时间算法，将多个小包一块发送
          这两种情况会导致黏包


      解决黏包问题
      1，传输的时候，先传递包大小，根据大小，确定接收值，返回收到后，再进行传输
      2，使用struct模块，传输的时候先将包大小传过去，在直接传输数据包


      1，不使用struct模块解决黏包问题，需要在发送你要发的数据之前，先计算数据大小，先告诉服务端要发的数据大小，然后服务端通过接受到数据大小来确定接收数值
       1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/14 22:40
 4 # @author   : aolishuai
 5 # @file     : server
 6 import socket
 7 
 8 sk = socket.socket()
 9 ip_port = ('127.0.0.1', 8010)
10 sk.bind(ip_port)
11 sk.listen()
12 conn, addr = sk.accept()
13 
14 while true:
15     cmd = input('请输入命令:').encode('gbk')
16     conn.send(cmd)
17     ret = conn.recv(1024).decode('utf-8')
18     conn.send(b'ok')
19     ret2 = conn.recv(int(ret)).decode('gbk')
20     print(ret2)
21 
22 
23 conn.close()
24 sk.close()

      　

       1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/14 22:40
 4 # @author   : aolishuai
 5 # @file     : client
 6 import socket,subprocess
 7 
 8 sk = socket.socket()
 9 ip_port = ('127.0.0.1',8010)
10 sk.connect(ip_port)
11 
12 while true:
13     msg = sk.recv(1024).decode('gbk')
14     ret = subprocess.popen(msg,shell=true,stdout=subprocess.pipe,stderr=subprocess.pipe)
15     std_out = ret.stdout.read()
16     std_err = ret.stderr.read()
17     num = str(len(std_out)+len(std_err)).encode('utf-8')
18     sk.send(num)
19     sk.recv(1024)
20     sk.send(std_out)
21     sk.send(std_err)
22 sk.close()

       

    2.  

      使用struct模块解决黏包问题，struct能把一个类型的数据，转换成相应的bytes类

       1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/15 10:56
 4 # @author   : aolishuai
 5 # @file     : server
 6 
 7 import socket,struct
 8 
 9 sk = socket.socket()
10 ip_port = ('127.0.0.1', 8010)
11 sk.bind(ip_port)
12 sk.listen()
13 conn, addr = sk.accept()
14 
15 while true:
16     cmd = input('请输入命令:').encode('gbk')
17     conn.send(cmd)
18     #ret = conn.recv(1024).decode('utf-8')
19     ret = conn.recv(4)
20     ret = struct.unpack('i',ret)[0]
21 
22 
23     #conn.send(b'ok')
24     ret2 = conn.recv(ret).decode('gbk')
25     print(ret2)
26 
27 
28 conn.close()
29 sk.close()
       1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/15 10:56
 4 # @author   : aolishuai
 5 # @file     : client
 6 import socket,subprocess,struct
 7 
 8 sk = socket.socket()
 9 ip_port = ('127.0.0.1',8010)
10 sk.connect(ip_port)
11 
12 while true:
13     msg = sk.recv(1024).decode('gbk')
14     ret = subprocess.popen(msg,shell=true,stdout=subprocess.pipe,stderr=subprocess.pipe)
15     std_out = ret.stdout.read()
16     std_err = ret.stderr.read()
17     #num = str(len(std_out)+len(std_err)).encode('utf-8')
18     num  = len(std_out)+len(std_err)
19     num = struct.pack('i',num)
20     sk.send(num)
21     #sk.recv(1024)
22     sk.send(std_out)
23     sk.send(std_err)
24 sk.close()

       


      　

2，socketserver

使用tcp时，server端和client端只能链一个，通过socketserver能够使多个client与server同时连接

启用的时候，只有server端需要继承socketserver服务

 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/16 13:25
 4 # @author   : aolishuai
 5 # @file     : socketserver
 6 
 7 import socketserver
 8 #必须创建一个类
 9 class myserver(socketserver.baserequesthandler):
10     def handle(self):
11         while true:
12             msg = self.request.recv(1024).decode('utf-8')
13             print(msg)
14             info = input('>>>')
15             self.request.send(info.encode('utf-8'))
16 
17 
18         #print(self.request.recv(1024))#self.request==conn
19 
20 
21 if __name__ == '__main__':
22     server = socketserver.threadingtcpserver(('127.0.0.1',8090),myserver)
23     server.serve_forever()
 1 #!/usr/bin/env python
 2 # -*- coding: utf-8 -*-
 3 # @time     : 2019/6/16 13:33
 4 # @author   : aolishuai
 5 # @file     : client
 6 import socket
 7 sk = socket.socket()
 8 sk.connect('127.0.0.1',8090)
 9 while true:
10     msg = input('>>>>>')
11     sk.send(msg.encode('utf-8'))
12     ret = sk.recv(1024).decode('utf-8')
13     print(ret)
14 sk.close()

 

您可能感兴趣的文章:

如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网