Day27 python 黏包 udp/tcp 解决黏包、模块socktserver、socketserver并发

1.黏包

# tcp协议在发送数据时,会出现黏包现象.
(1)数据粘包是因为在客户端/服务器端都会有一个数据缓冲区，
缓冲区用来临时保存数据，为了保证能够完整的接收到数据，因此缓冲区都会设置的比较大。
(2)在收发数据频繁时，由于tcp传输消息的无边界,不清楚应该截取多少长度
导致客户端/服务器端,都有可能把多条数据当成是一条数据进行截取，造成黏包

例：下面三种方式采取的是，1.可以使用模块time，在客户端或者服务端发送方或者收到数据的一方时间稍微延缓，这样可以做到不黏包。

2.本例中的服务端发送数据时，先发一个数据给客户端，让客户端知道将要接受多少数据，这样也不会黏包。(方法1)

3.方法1的弊端就是一旦服务器发送的数据过多，客户端不需要每次去接受多少个数据然后再次就行赋值，直接写上接受8个字节就行，服务器端利用"00000120"，让客户端知道你每次接受8个字节就行了，

res0 = int(sk.recv(8).decode("utf-8")) 也就是不需要每次去改动8这个数字，每次接受8个字节就行，服务器端按照这样的方式就行发送就可以。

上面的数字就是你需要接受的字节数。这样也不会造成黏包。

4.方法三是按照使用socketserver就行把要发送的任意数字使用stuct.pack()就行把数据就行打包成4个字节就行发送，然后让客户端知道你接受的是4个字节，然后再客户端处，使用struct.unpack()就是把4个字节的包就行解压，得到原有的数据，这样也不会造成黏包。

5.上面的情况都是按照服务器端给客户端发送2次数据建立而来的，一般2次数据不加任何东西的时候，由于tcp是无边界的，不清楚该接受多少个字节，客户端第一次接受recv(10) 客户端第二次接受recv(10) ，服务器方第一次发送的是helllo第二次发送的是world，由于无边界会造成第一次接受的是b"helloworl" 第二次接受的是b"d" 对此展开而来的。

解决方法一：(就不会造成黏包)

客户端代码：

# ### 客户端
import socket
import time
sk = socket.socket()
sk.connect( ("127.0.0.1",9000) )

# time.sleep(0.2)
res0 = int(sk.recv(1).decode("utf-8")) #res0 "6"
print(res0)
res1 = sk.recv(res0)
print(res1)
# print(res1.decode("utf-8"))
res2 = sk.recv(10)
print(res2)
sk.close()

服务器端：

# ### 服务端
import socket
import time
sk = socket.socket()

# 在bind方法之前加上这句话，可以让一个端口重复使用
sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
# 绑定地址端口(在网络上注册主机)
sk.bind( ("127.0.0.1",9000) )
sk.listen()

conn, addr = sk.accept()
conn.send("6".encode("utf-8"))
message = "hello,"
conn.send(message.encode("utf-8"))
# time.sleep(0.1)
conn.send("world".encode("utf-8"))


# 四次挥手
conn.close()
# 退还端口
sk.close()
小结：在tcp就行发包的时候，可以先一个数据让客户端知道，我们将会发多大的数据包给他，如上就是先发一个6然后再发送"hello"和"world"
第一次接收到hello之后，接受第二个数据就不会造成数据的黏包。

 方法二：
利用recv（8）接受8个字节，这样服务器就可以发送数据。
客户端：

# ### 客户端
import socket
import time
sk = socket.socket()
sk.connect( ("127.0.0.1",9000) )

# time.sleep(0.2)
res0 = int(sk.recv(8).decode("utf-8")) #res0 "6"
print(res0)
res1 = sk.recv(res0)
print(res1)
# print(res1.decode("utf-8"))
res2 = sk.recv(10)
print(res2)
sk.close()

 服务器端

# ### 服务端
import socket
import time
sk = socket.socket()

# 在bind方法之前加上这句话，可以让一个端口重复使用
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定地址端口(在网络上注册主机)
sk.bind( ("127.0.0.1",9000) )
sk.listen()

conn,addr = sk.accept()
conn.send("00000120".encode("utf-8"))
message = "hello," * 20
conn.send(message.encode("utf-8"))
# time.sleep(0.1)
conn.send("world".encode("utf-8"))


# 四次挥手
conn.close()
# 退还端口
sk.close()
# 在服务器端使用#time.sleep（0.1）延迟服务器端给客户端发数据也是可以的，也就是服务器端先发送一个数据然后，等待客户端接收到数据之后再次发送第二个数据这样子也行。

方法三：
# 使用模块socketserver

客户端代码：

# ### 客户端
import socket
import struct
import time
sk = socket.socket()
sk.connect( ("127.0.0.1",9000) )
time.sleep(0.1)
# 接受4个字节长度, 他是实际要发送的那个数字转化来的.
n = sk.recv(4)
#
n = struct.unpack("i",n)[0]
print(n)

# 接下来接受服务端发送过来的数据
res1 = sk.recv(n)
print(res1.decode("utf-8"))
res2 = sk.recv(1024)
print(res2.decode("utf-8"))

# 空格不是ascii编码中的,大家注意.
sk.send(b"i_love_you")

# 关闭连接
sk.close()

服务器代码：

# ### 服务端
import socket
import struct

sk = socket.socket()
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind( ("127.0.0.1",9000) )
sk.listen()

conn,addr = sk.accept()
inp = input(">>>msg:")
msg = inp.encode("utf-8")
# 发送数据的长度通过pack进行转换,变成具有固定长度的4个字节的值
res = struct.pack("i",len(msg))

conn.send(res)
# 接下来,开始真正的发送数据
conn.send(msg)
conn.send("world".encode("utf-8"))

res = conn.recv(1024)
print(res)
print(res.decode("utf-8"))
# 四次挥手
conn.close()
# 退还端口
sk.close()

小结：使用了，socketserver之后，服务器给客户端第一次发送数据，无论发送的发送的长度有多长，利用struct.pack("i",len(msg))计算之后的
值都是按按照4个字节长度发送，然后把这个字节发送给客户端，让它知道第一次接受4个字节长度的就行了，在客户端使用unpack()，就行把得到的数据就行
恢复原来的数据，这样就不会造成黏包。

2.黏包出现的两种情况

#黏包现象一:
在发送端,由于两个数据短,发送的时间隔较短,所以在发送端形成黏包
#黏包现象二:
在接收端,由于两个数据几乎同时被发送到对方的缓存中,所有在接收端形成了黏包
#总结:
发送端,包之间时间间隔短 或者 接收端,接受不及时, 就会黏包
核心是因为tcp对数据无边界截取,不会按照发送的顺序判断

3.解决黏包问题

#解决黏包场景:
应用场景在实时通讯时,需要阅读此次发的消息是什么
#不需要解决黏包场景:
下载或者上传文件的时候,最后要把包都结合在一起,黏包无所谓.

4.模块socketserver

#网络协议的最底层就是socket,基于原有socket模块,又封装了一层,就是socketserver
socketserver 为了实现tcp协议,server端的并发.

 基本用法：(解决黏包的方法三种会使用到的知识点)

import struct
# pack     把任意长度的数字转化成具有固定4个字节长度的字节流
# unpack   将4个字节的值恢复成原本的数据,最后返回一个元组
# i => int 我要转化的当前数据类型是整型
res = struct.pack("i",304535345)
print(res)
print(len(res))

res = struct.unpack("i",res)
print(res)
print(res[0],type(res[0]))

 5.sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)加上可以实现端口的互用

6.socketserver并发

客户端1代码：(不带循环的客户端就行访问服务器)

# ### 客户端
import socket
sk = socket.socket()
sk.connect( ("127.0.0.1",9000) )
sk.close()

'''
try:
    print(name)
# 无论是否报错,都会执行finally里面代码块;
finally:
    pass
'''
# print(name)
"""
如果有一些语句,即使在发生报错的情况也仍然要调用或处理一些逻辑,那么使用finally
"""
# try:
    # print(name)
# finally:
    # print(123)
    # print(456)
    
'''
try这个代码块如果有错误,不执行else代码块中的内容
如果没有报错,那么执行else代码块中的内容.
try ... except ... else 要配合使用 else不能单独拿出来和try使用.
try ... finally ... 可以配合在一起使用.
'''
'''
try:
    # print(name)
    print(123)
except:
    pass
else:
    print(789)
'''

服务器1代码：

import socketserver
# 需要自定义一个类,并且继承socketserver.BaseRequestHandler
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        #<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 54088)>
        print(self.request) 
        print("--->执行这句话")

# Threading( (ip,端口号)   ,  自定义类 )
server = socketserver.ThreadingTCPServer( ("127.0.0.1",9000) , MyServer)
# 循环调用
server.serve_forever()
服务器代码：
只要有客户端连接服务器就会打印出下面的代码。self.request相当于，接收到有人连接服务器，myserver这个类下面的函数handle就会自动去处理。看看是谁连接到了我，从而支持并发。

# 由于客户端没有给服务器发送消息，服务器这边采用可socketserver支持多人连接。

# 带循环的客户端2

import socket
sk = socket.socket()
sk.connect( ("127.0.0.1",9000) )

while True:    
    sk.send(b"wangwen_dashuaguo")
    msg = sk.recv(1024)
    print(msg)


sk.close()

# 服务器代码2：

import socketserver
class MyServer(socketserver.BaseRequestHandler):
    # 在handle里面自定义收发逻辑
    def handle(self):
        print("--->这句话被执行了")
        
        conn = self.request
        while True:    
            msg = conn.recv(1024).decode("utf-8")
            print(msg)
            conn.send(msg.upper().encode("utf-8"))
# 产生一个对象    
server = socketserver.ThreadingTCPServer( ("127.0.0.1",9000) ,MyServer )
# 循环调用
server.serve_forever()

运行代码：

 小结：

1.上面开的三个客户端都是发送wangwen_dashuaguo

2.服务器这边的逻辑就是只要有客户端来连接我我就使用

# 产生一个对象    
server = socketserver.ThreadingTCPServer( ("127.0.0.1",9000) ,MyServer )
来产生一个对象就行处理，在这个类当中可以发现只要是客户端给我发消息我就可以接受到，然后再将他发送的内容发送给他。从而形成了并发，可以是多个客户端连接服务器。conn = self.request也很关键。