Go语言视频零基础入门到精通

admin

python--(socket与粘包解决方案)

1. 一.[b]socket[/b][b]:[/b]
2.     Socket 是任何一种计算机网络通讯中最基础的内容。例如当你在浏览器地址栏中输入 http://www.cnblogs.com/ 时，你会打开一个套接字，然后连接到 http://www.cnblogs.com/ 并读取响应的页面然后然后显示出来。而其他一些聊天客户端如 gtalk 和 skype 也是类似。任何网络通讯都是通过 Socket 来完成的
3.         打开 => 读写 => 关闭

复制代码

1. socket ftp传输:

复制代码

  

1. import socket
2. server = socket.socket()  #创建一个手机#创建了一个socket对象
3. ip_port = ("192.168.15.113",8001)  #创建了一张电话卡
4. server.bind(ip_port) #插上电话卡#绑定IP地址和端口
6. server.listen() #开机#监听IP地址和端口
7. conn, addr = server.accept()  #等着别人给我打电话,阻塞住#等待客链接
8. from_client_msg = conn.recv(1024) #接收消息#1024为消息大小,单位B,MB = 1024KB,1KB = 1024B
9. from_client_msg = from_client_msg.decode("utf-8")#接收的消息是bytes类型,需要转换为字符串
10. print(from_client_msg)
12. conn.send("死鬼,十点".encode("utf-8"))  #发送消息
14. conn.close()#关闭链接
15. server.close()

复制代码

  
socket ftp传输,服务端




  

1. import socket
2. client = socket.socket()
3. server_ip_port = ("192.168.15.113",8001)
4. client.connect(server_ip_port)#链接服务端
6. client.send("约吗".encode("utf-8")) #发消息#send里面的消息必须是字节类型的
8. from_server_msg = client.recv(1024) #阻塞住,等待接收消息
9. from_server_msg = from_server_msg.decode("utf-8")
10. print(from_server_msg)
12. client.close()

复制代码

  
socket ftp传输,客户端

1. socket udp传输:

复制代码

  

1. import socket
2. udp_server = socket.socket(type=socket.SOCK_DGRAM)  #创建一个udp协议下的socket,需要使用参数type#DGRAM : datagram  数据报
3. ip_port = ("192.168.15.113",8001)#拿到一个地址,启动程序的时候,告诉电脑,你给我这个程序分配8001端口.
4. udp_server.bind(ip_port) #绑定IP地址和端口
7. from_client_msg,client_addr = udp_server.recvfrom(1024)#阻塞住了,接收客户端消息#from_client_msg来自客户端的消息,client_addr客户端的地址("192.168.15.113", 8001)
9. udp_server.sendto(b"gunduzi",client_addr)#发送消息
11. udp_server.close()#关闭udp的socket对象

复制代码

  
socket udp传输,服务端




  

1. import socket
2. udp_client = socket.socket(type=socket.SOCK_DGRAM)
3. server_ip_port = ("192.168.15.113",8001)
5. udp_client.sendto(b"hello",server_ip_port)
7. from_server_msg,server_addr = udp_client.recvfrom(1024)
8. print(from_server_msg)
9. print(server_addr)
11. udp_client.close()

复制代码

  
socket udp传输,客户端


socketserver:
　　它是在socket的基础上进行了一层封装，也就是说底层还是调用的socket，在py2.7里面叫做SocketServer也就是大写了两个S，在py3里面就小写了。需要用它来实现并发，也就是同时可以和多个客户端进行通信，多个人可以同时进行上传下载等。
  



  

1. import socketserver
3. class MyServer(socketserver.BaseRequestHandler)
4. #1.定义一个类,2.类里面继承socketserve.BaseRequestHandler
6.     def handle(self):   #类里面定义一个handle方法,handle名称不能变
7.         while 1:
8.             from_client_data = self.request.recv(1024).decode("utf-8")
9.         # self.request      #conn链接通道
11.             print(from_client_data)
12.             server_input = ("辉哥说>>>>")
13.             self.request.send(server_input.encode("utf-8"))
14.         # self.request.send(server_input.encode("utf-8")
15.         # self.request.close()
17. if __name__ == "__main__":
18.     ip_port = ("127.0.0.1",8001)#服务端的ip地址和端口
19.     socketserver.TCPServer.allow_reuse_address = True
21.     server = socketserver.ThreadingTCPServer(ip_port, MyServer)# 绑定IP地址和端口,并且启动我定义的上面这个类
23.     server.serve_forever()#永久的给我执行下去

复制代码

  
服务端代码解析

  



  

1. import socket
3. tcp_client = socket.socket()
4. server_ip_port = ("127.0.0.1",8001)
5. tcp_client.connect(server_ip_port)
6. while 1:
7.     client_msg = input("大阳哥>>>")
8.     tcp_client.send(client_msg.encode("utf-8"))
10.     from_server_msg = tcp_client.recv(1024).decode("utf-8")
11.     print(from_server_msg)
13. tcp_client.close()

复制代码

  
客户端代码解析

---

  
socket相关常用操作:

1. sk.bind(address)
2. 　　s.bind(address)
3. 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host, port）的形式表示地址。
5. sk.listen(backlog)
6. 　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。
7. backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
8. 这个值不能无限大，因为要在内核中维护连接队列
10. sk.setblocking(bool)
11. 　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。
13. sk.accept()
14. 　　接受连接并返回（conn, address）, 其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
15. 　　接收TCP
16. 客户的连接（阻塞式）等待连接的到来
18. sk.connect(address)
19. 　　连接到address处的套接字。一般，address的格式为元组（hostname, port）, 如果连接出错，返回socket.error错误。
21. sk.connect_ex(address)
22. 　　同上，只不过会有返回值，连接成功时返回
23. 0 ，连接失败时候返回编码，例如：10061
25. sk.close()
26. 　　关闭套接字
28. sk.recv(bufsize[, flag])
29. 　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。
31. sk.recvfrom(bufsize[.flag])
32. 　　与recv()
33. 类似，但返回值是（data, address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
35. sk.send(string[, flag])
36. 　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。
38. sk.sendall(string[, flag])
39. 　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
40. 内部通过递归调用send，将所有内容发送出去。
42. sk.sendto(string[, flag], address)
43. 　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
45. sk.settimeout(timeout)
46. 　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如
47. client
48. 连接最多等待5s ）
50. sk.getpeername()
51. 　　返回连接套接字的远程地址。返回值通常是元组（ipaddr, port）。
53. sk.getsockname()
54. 　　返回套接字自己的地址。通常是一个元组(ipaddr, port)
56. sk.fileno()
57. 　　套接字的文件描述符

复制代码

---

2. 二.[b]粘包[/b]

复制代码

缓冲区 : 暂时存放传输数据的,防止你的程序在发送数据的时候卡住,提高代码运行效率
输入缓冲区:recv
输出缓冲区:send
缓冲区有长度限制
MTU:最大传输单元,网络层限制是1500B,每次发送数据的时候最好不要超过这个数

1. [/code]
2. [b]粘包现象:[/b]
3. 1 连续发送小的数据,间隔时间很短,有可能一次就接收到了这几个连续的拼接在一起的小数据.  #原因:为了提高tcp传输效率,内部提供了一个叫做Nagel算法,他的意思就是为了避免你连续发送小的数据.
4. [code]

复制代码

2 当你一次接收的数据长度小于你一次发送的数据长度,那么一次接受完剩下的数据会在下一次接收数据的时候被一起接收.#原因面向流的传输
粘包的根本原因:
两端互相不知道对方发送数据的长度
  
解决方案一:
发送消息之前,先计算要发送消息的长度,然后先将消息长度发送过去,对方给你回一个确认收到长度的信息,然后根据接收到的消息长度来修改自己一次接收消息的大小
这个过程多了一次交互.
解决方案二:

1. [b]struct:
2. [/b]

复制代码

  

1. import struct
2. num = 156
3. #将int类型的数据打包成4个字节的数据
4. num_stru = struct.pack("i",num)
5. print(len(num_stru))
6. print(num_stru)
7. print("11111111111111111111111111111111")
9. #在通过int类型解包,将前面打包的数据解包成打包之前的int数据
10. num2 = struct.unpack("i",num_stru) #解包出来是个元组
11. print(num2)#(156,)
12. print(num2[0])

复制代码

  
神奇的打包工具struck

3. ftp传输 案例:

复制代码

  

1. 服务端:
2. import  socketserver
3. # 服务端
5. class Myserver(socketserver.BaseRequestHandler):
7.     def handle(self):
9.         conn = self.request
10.         conn.sendall(bytes("你好，我是孔二楞",encoding="utf-8"))
11.         while True:
12.             ret_bytes = conn.recv(1024)
13.             ret_str = str(ret_bytes,encoding="utf-8")
14.             if ret_str == "q":
15.                 break
16.             conn.sendall(bytes(ret_str+"你真无聊~",encoding="utf-8"))
18. if __name__ == "__main__":
19.     server = socketserver.ThreadingTCPServer(("192.168.15.70",8080),Myserver)
20.     server.serve_forever()
22. 客户端:
23. import socket
25. obj = socket.socket()
27. obj.connect(("192.168.15.70",8080))
29. ret_bytes = obj.recv(1024)
30. ret_str = str(ret_bytes,encoding="utf-8")
31. print(ret_str)
33. while True:
34.     inp = input("你好请问您有什么问题？ \n >>>")
35.     if inp == "q":
36.         obj.sendall(bytes(inp,encoding="utf-8"))
37.         break
38.     else:
39.         obj.sendall(bytes(inp, encoding="utf-8"))
40.         ret_bytes = obj.recv(1024)
41.         ret_str = str(ret_bytes,encoding="utf-8")
42.         print(ret_str)

复制代码

  
案例一 自动回复聊天

1. [/code]
2.   
4. [img]http://www.itdaan.com/i/b7fe6069c35a2fa578b04e8595a132fc1.jpg[/img]
5. [img]http://www.itdaan.com/i/b7fe6069c35a2fa578b04e8595a132fc2.jpg[/img]
6.   
7.   [code]import socket
8. import struct
9. import json
10. import os
11. tcp_server = socket.socket()
12. ip_port = ("127.0.0.1",8001)#本机回环地址,供内部程序之间测试用
13. tcp_server.bind(ip_port)
14. tcp_server.listen()
15. client_file_path = r"F:\pp"
17. conn,adddr = tcp_server.accept()
18. file_info_stru = conn.recv(4)#首先接收到文件信息长度转换出来的4个字节的数据
19. file_info_len = struct.unpack("i",file_info_stru)[0]#解包文件信息的长度
20. client_file_info = conn.recv(file_info_len).decode("utf-8")
21. abc_file_info = json.loads(client_file_info)#将接收到的json字符串反序列化
22. print("abc_file_info>>>",abc_file_info)
23. client_file_size = abc_file_info["file_size"]
25. recv_all_size = 0
26. client_full_path = client_file_path + "\" + abc_file_info["file_name"]
27. # client_full_path = os.path.join(client_file_path,abc_file_info["file_name"])
28. with open(client_full_path,"wb") as f:
29.     while recv_all_size < client_file_size:
30.         every_recv_data = conn.recv(1024)
31.         f.write(every_recv_data)
32.         recv_all_size += len(every_recv_data)
35. conn.send("小伙牛逼啊,上传成功!".encode("utf-8"))
36. conn.close()
37. tcp_server.close()

复制代码

  
案例二 大于10M文件上传服务端




  

1. import socket
2. import struct
3. import json
4. import os
5. tcp_client = socket.socket()
6. server_client = socket.socket()
7. server_ip_port = ("127.0.0.1",8001)
8. tcp_client.connect(server_ip_port)
9. read_size = 1024
11. file_info = {
12.     "file_path":r"F:\untitled\10.18\jj\aaa.mp4",
13.     "file_name":"aaa.mp4",
14.     "file_size":None,
15. }
16. file_size = os.path.getsize(file_info["file_path"])#获取文件大小
17. file_info["file_size"] = file_size#将文件大小添加到文件信息的字典中
18. file_info_json = json.dumps(file_info)#因为我们要发送的数据是字节类型,那么必须将字典转换为bytes类型,但字典不能直接转换为byte,所以用过先转换成字符串
19. file_info_len = len(file_info_json) #获取字符串的长度
20. file_info_stru = struct.pack("i",file_info_len)#将长度打包为四个字节
21. tcp_client.send(file_info_stru)#将打包好的4个自己的数据和我的文件信息数据一起发送给了服务端
22. tcp_client.send(file_info_json.encode("utf-8"))
24. all_file_data = b"" #统计文件数据
25. all_size_len = 0    #统计文件数据长度
27. with open(file_info["file_path"],"rb") as f:
28.     while all_size_len < file_size:
29.         every_read_data = f.read(read_size)
30.         all_file_data += every_read_data
31.         all_size_len += len(every_read_data)
32.         tcp_client.send(every_read_data)#发送每次读取的数据
34. print(tcp_client.recv(1024).decode("utf-8"))
35. tcp_client.close()

复制代码

  
案例二 大于10M文件上传客户端

  



  

1. import socket
2. import subprocess
3. import struct
4. server = socket.socket()
5. ip_port = ("192.168.15.33",8001)
6. server.bind(ip_port)
7. server.listen()
8. conn,addr = server.accept()
10. while 1:
11.     print("等待接收消息...")
12.     from_client_cmd = conn.recv(1024).decode("utf-8")#接收客户端消息
13.     print(from_client_cmd)
15.     sub_obj = subprocess.Popen(   #通过subprocess模块执行服务端指令,并拿到指令结果
16.         from_client_cmd,            #客户端指令
17.         shell = True,
18.         stdout = subprocess.PIPE,   #标准输出:正确指令的执行结果
19.         stderr = subprocess.PIPE,   #标准错误输出:错误指令的执行结果
20.     )
22.     server_cmd_msg = sub_obj.stdout.read()
23.     #server_cmd_msg = sub_obj.stderr.read() #接收到的返回信息是bytes类型,并且windoes系统的默认编码为gbk
24.     cmd_msg_len = len(server_cmd_msg) #计算你要发送的数据长度
25.     msg_len_stru = struct.pack("i",cmd_msg_len)#先对数据长度进行打包,打包成4个字节的数据,目的是为了和你将要发送的数据拼接在一起,就像我们自制一个消息头.
26.     conn.send(msg_len_stru)        #首先发送打包成功后的那4个字节的数据
27.     conn.sendall(server_cmd_msg)   #循环send数据,直到数据全部发送成功
29. conn.close()
30. server.close()

复制代码

  
案例三 解决粘包问题服务端




  

1. import socket
2. import struct
3. client = socket.socket()
4. server_ip_port = ("192.168.15.33",8001)
5. client.connect(server_ip_port)
7. while 1:
8.     msg = input("请输入要执行的命令>>>>>")
9.     client.send(msg.encode("utf-8"))
11.     from_server_msglen = client.recv(4)#先接受服务端要发送给我的数据长度,前四个字节,固定的
12.     unpack_len_msg = struct.unpack("i",from_server_msglen)[0]
14.     recv_msg_len = 0
15.     all_msg = b""
16.     while recv_msg_len < unpack_len_msg:
17.         every_recv_date = client.recv(1024)
18.         all_msg += every_recv_date  #将每次接收到的数据进行拼接和统计
19.         recv_msg_len += len(every_recv_date) #对每次接受到的数据进行累加
21.     print(all_msg.decode("gbk"))
22. client.close()

复制代码

  
案例三 解决粘包问题客户端

  
  

复制代码

  

复制代码

复制代码