socket : 通络通信过程中,信息拼接的工具(中文:套接字)
开发中,一个端口只对一个程序生效,在测试时,允许端口重复捆绑 (开发时删掉), 在bind方法之前加上这句话，可以让一个端口重复使用: sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
TCP: 服务端和客户端简单的一次性通信
# 服务端 import socket # 1. 创建socket对象 sk = socket.socket() # 2. 绑定对应IP和端口(注册网络,让其他主机能够找到) sk.bind(("127.0.0.1",9000)) # 127.0.0.1 代表本地IP # 3. 开启监听 sk.listen() # 4. 建立三次握手 addr接收客户端的IP和端口号 conn,addr = sk.accept() # 5. 收发数据(recv里面的参数单位是字节,表示一次最多接收多少数据) res = conn.recv(1024) print(res) print(res.decode("utf-8")) # 6. 四次挥手 conn.close() # 7. 退还端口 sk.close() # 客户端 import socket # 1. 创建一个socket对象 sk = socket.socket() # 2. 与服务器进行连接 sk.connect(("127.0.0.1",9000)) # 3. 发送数据 sk.send("今天下了一天的雨".encode("utf-8")) # 4. 关闭连接 sk.close()
TCP: 服务端和客户端循环通信
# TCP循环通信: # 服务端 import socket # 1. 创建一个socket对象 sk = socket.socket() # 2. 在网络中注册主机(绑定IP和端口) sk.bind(("127.0.0.1",9000)) # 3. 监听 sk.listen() # 4. 建立三次握手 # 5. 接收数据 while True: # 保证服务端永不关闭,随时能跟客户端连接 conn, addr = sk.accept() while True: res = conn.recv(1024) print(res.decode("utf-8")) str1 = input("服务端想给客户端发送: ") conn.send(str1.encode("utf-8")) if str1.upper() == "Q": break # 6.四次挥手 conn.close() # 7.退还端口 sk.close() # 客户端 import socket # 1. 建立一个socket对象 sk= socket.socket() # 2. 连接服务端 sk.connect(("127.0.0.1",9000)) # 3. 发送数据 while True: strvar = input("客户端想给服务端发送的消息为: ") sk.send(strvar.encode("utf-8")) res = sk.recv(1024) if res.upper() == b"Q": break print(res.decode("utf-8")) # 4.断开连接 sk.close()
TCP的黏包现象:
(1)数据粘包是因为在客户端/服务器端都会有一个数据缓冲区，
缓冲区用来临时保存数据，为了保证能够完整的接收到数据，因此缓冲区都会设置的比较大。
(2)在收发数据频繁时，由于tcp传输消息的无边界,不清楚应该截取多少长度
导致客户端/服务器端,都有可能把多条数据当成是一条数据进行截取，造成黏包
黏包现象一:
在发送端,由于两个数据短,发送的时间隔较短,所以在发送端形成黏包
黏包现象二:
在接收端,由于两个数据几乎同时被发送到对方的缓存中,所有在接收端形成了黏包
总结:
发送端,包之间时间间隔短 或者 接收端,接受不及时, 就会黏包
核心是因为tcp对数据无边界截取,不会按照发送的顺序判断
# TCP的黏包现象 # 服务端 import socket sk = socket.socket() sk.bind(("127.0.0.1",9000)) sk.listen() coon,addr = sk.accept() coon.send("下了一天的雨".encode()) coon.send("适合发呆".encode()) coon.close() sk.close() # 客户端 import socket import time sk = socket.socket() sk.connect(("127.0.0.1",9000)) time.sleep(0.1) res1 = sk.recv(1024) print(res1.decode()) res2 = sk.recv(1024) print(res2.decode()) # 下了一天的雨适合发呆 两个数据粘在了一起,这就是数据的黏包 sk.close()
TCP黏包解决方式:
# TCP的黏包现象 # 服务端 # 方式一: import socket sk = socket.socket() sk.bind(("127.0.0.1",9000)) sk.listen() coon,addr = sk.accept() # 在发送真实数据之前,先发送真实数据的大小 coon.send("18".encode()) coon.send("下了一天的雨".encode()) coon.send("适合发呆".encode()) coon.close() sk.close() # 客户端 import socket import time sk = socket.socket() sk.connect(("127.0.0.1",9000)) time.sleep(0.1) res = sk.recv(2) n = int(res.decode()) res1 = sk.recv(n) print(res1.decode()) res2 = sk.recv(1024) print(res2.decode()) # 下了一天的雨 # 适合发呆 sk.close() ############## # TCP的黏包现象 # 服务端 # 方式二: import socket sk = socket.socket() sk.bind(("127.0.0.1",9000)) sk.listen() coon,addr = sk.accept() # 在发送真实数据之前,先发送真实数据的大小 coon.send("00000018".encode()) # 以免客户端每次都要改第一次接收字节数 coon.send("下了一天的雨".encode()) coon.send("适合发呆".encode()) coon.close() sk.close() # 客户端 import socket import time sk = socket.socket() sk.connect(("127.0.0.1",9000)) time.sleep(0.1) res = sk.recv(8) # 将第一次接受的大小固定 n = int(res.decode()) res1 = sk.recv(n) print(res1.decode()) res2 = sk.recv(1024) print(res2.decode()) # 下了一天的雨 # 适合发呆 sk.close() # 但是方式一和方式二都太麻烦,每次都需要改动
TCP黏包解决方式三(推荐)
""" pack: 把任意长度的数字转化成居右4个字节的固定长度的字节流 unpack: 把4个字节值恢复成原本的数字,返回是元组 # 整型用i表示, 浮点型用f表示, 字符串用s表示 """ # TCP的黏包现象 # 服务端 # 方式三: 引入struct import socket import struct sk = socket.socket() sk.bind(("127.0.0.1",9000)) sk.listen() coon,addr = sk.accept() strvar = input("请输入数据:") msg = strvar.encode() length = len(msg) res = struct.pack("i",length) # 将要发送的第一个数据的长度先用struct进行压缩 coon.send(res) coon.send(strvar.encode()) coon.send("适合发呆".encode()) coon.close() sk.close() # 客户端 import socket import time import struct sk = socket.socket() sk.connect(("127.0.0.1",9000)) time.sleep(0.1) res = sk.recv(4) # struct压缩的数据永远都是4个字节 tup = struct.unpack("i",res) print(tup[0]) # 18 res1 = sk.recv(tup[0]) print(res1.decode()) res2 = sk.recv(1024) print(res2.decode()) # 下了一天的雨 # 适合发呆 sk.close()
解决黏包场景: 应用场景在实时通讯时,需要阅读此次发的消息是什么
不需要解决黏包场景: 下载或者上传文件的时候,最后要把包都结合在一起,黏包无所谓.
udp数据传输简单通信
# dup 数据传输 # 服务端 import socket # 1. 创建一个socket对象 type=socket.SOCK_DGRAM表明创建的是UDP协议对象 sk = socket.socket(type=socket.SOCK_DGRAM) # 2. 绑定IP和端口号 sk.bind(("127.0.0.1",9000)) # 4. 接收消息,(UDP作为服务端的时候,第一次肯定是接收消息) msg,cli_addr = sk.recvfrom(1024) print(msg.decode()) # 今天天气咋样啊? print(cli_addr) # ('127.0.0.1', 64877) # 发送消息给客户端 msg = "下了一天的雨" sk.sendto(msg.encode(),cli_addr) # 5. 关闭连接 sk.close() # 客户端 import socket # 1. 创建socket对象 sk = socket.socket(type=socket.SOCK_DGRAM) # 2. 发送数据 msg = "今天天气咋样啊?" sk.sendto(msg.encode(),("127.0.0.1",9000)) msg,ser_addr = sk.recvfrom(1024) print(msg.decode()) # 下了一天的雨 print(ser_addr) # ('127.0.0.1', 9000) # 3. 断开连接 sk.close()
udp 数据传输循环通信
# udp循环通信 # 服务端 import socket sk = socket.socket(type=socket.SOCK_DGRAM) sk.bind(("127.0.0.1",9000)) while True: while True: msg,cli_addr = sk.recvfrom(1024) print(msg.decode()) msg = input("服务端给客户端发送的消息: ") sk.sendto(msg.encode(), cli_addr) if msg.upper() == "Q": break sk.close() # 客户端 import socket sk = socket.socket(type=socket.SOCK_DGRAM) while True: msg = input("客户端给服务端发送的消息: ") sk.sendto(msg.encode(),("127.0.0.1",9000)) msg, ser_addr = sk.recvfrom(1024) if msg.upper() == b"Q": break print(msg.decode()) sk.close()
tcp协议:
缺点:接收时数据之间无边界,有可能粘合几条数据成一条数据,造成黏包
优点:不限制数据包的大小,稳定传输不丢包
udp协议:
优点:接收时候数据之间有边界,传输速度快,不黏包
缺点:限制数据包的大小(受带宽路由器等因素影响),传输不稳定,可能丢包
tcp和udp对于数据包来说都可以进行拆包和解包,理论上来讲,无论多大都能分次发送
但是tcp一旦发送失败,对方无响应(对方无回执),tcp可以选择再发,直到对应响应完毕为止
而udp一旦发送失败,是不会询问对方是否有响应的,如果数据量过大,易丢包