socket模块(套字节)、通信循环、链接循环

阅读目录

• socket模块(套接字)
• 实际应用
• 通讯循环
• 代码优化和链接循环
• 半连接池
• 黏包现象
• struct模块

 

---

今日内容

• socket模块(套接字)

• 实际应用

• 通讯循环

• 代码优化和链接循环

• 半连接池

• 黏包现象

• struct模块

• 黏包代码实战

回到顶部

socket模块(套接字)

如果我们需要编写基于网络进行数据交互的程序 意味着我们需要自己通过代码来控制我们之前所学习的OSI七层(很繁琐 很复杂 类似于我们自己编写操作系统)

socket类似于操作系统 封装了丑陋复杂的接口提供简单快捷的接口

socket也叫套接字
	基于文件类型的套接字家族(单机)
  	AF_UNIX
  基于网络类型的套接字家族(联网)
  	AF_INET
 
它为我们提供了快捷方式，不需要我们自己去处理OSI七层的每一层
import socket
socket.socket()  产生socket对象
bind()					 绑定地址
listen()				 半连接池
accept()				 等待客户端链接
send()					 发送消息
recv()					 接收消息
connect()				 链接服务端

回到顶部

实际应用

# 服务端
import socket

# 1.产生一个socket对象并指定采用的通信协议(TCP)
server = socket.socket()  # 括号内不写参数 默认就是TCP协议 family=AF_INET基于 网络的套接字 type=SOCK_STREAM流式协议即TCP协议
# 2.绑定一个固定的地址(服务端必备的条件)
server.bind(('127.0.0.1', 8080))  # 127.0.0.1为本地回环地址 只有自己的电脑可以访问
# 3.设立半连接池
server.listen(5)
# 4.等待接客
sock, addr = server.accept()  # sock,addr 三次握手
print(sock, addr)  # sock就是双向通道 addr就是客户地址
# 5.服务客人
data = sock.recv(1024)  # 接收客户端发送过来的消息 1024字节
print(data.decode('utf8'))
sock.send('客人你好'.encode('utf8'))  # 给客户端发送消息 注意消息必须是bytes类型
# 6.关闭双向通道
sock.close()  # 四次挥手
# 7.关闭服务端
server.close()  # 店倒闭了

# 客户端
import socket

# 1.产生一个socket对象并指定采用的通信协议(TCP)
client = socket.socket()
# 2.通过服务端的地址链接服务端
client.connect(('127.0.0.1', 8080))
# 3.直接给服务端发送消息
client.send('我来了'.encode('utf8'))
# 4.接收服务端发送过来的消息
data = client.recv(1024)
print(data.decode('utf8'))
# 5.断开与服务端的链接
client.close()

回到顶部

通讯循环

# 1.解决信息固定的问题 聊天内容自定义
	利用input获取用户输入
# 2.解决通信循环的问题 让聊天循环起来
	将双方用于数据交互的代码循环起来 聊天部分用循环包起来	
    
# 服务端
import socket

server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)

sock, addr = server.accept()
while True:
    data = sock.recv(1024)  # 获取别人说什么  
    print(f'来自于客户端{addr}的消息:', data.decode('utf8'))  # 解码别人说的啥    
    msg = input('请输入发送给客户端的消息:').strip()
    sock.send(msg.encode('utf8'))  # 回复别人的话 因为基于网络传输 使用二进制编码

    

# 客户端
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))
while True:
    msg = input('请输入您想要发送给服务端的消息:').strip()
    client.send(msg.encode('utf8'))  # 给服务端发消息
    data = client.recv(1024)  # 接收服务端回复的消息
    print('来自于服务端发送过来的消息:', data.decode('utf8'))

回到顶部

代码优化和链接循环

1.用户的输入消息不能为空
	本质其实是两边不能都是recv或者send 一定是一方收一方发
    统计长度然后进行判断(len)
# 客户端
while True:
    msg = input('请输入您想要发送给服务端的消息:').strip()
    if len(msg) == 0: # 判断输入的字节是否等于0
        print('不能发送空消息')
        continue
    client.send(msg.encode('utf8'))  # 给服务端发消息
    data = client.recv(1024)  # 接收服务端回复的消息
    print('来自于服务端发送过来的消息:', data.decode('utf8'))
    
    
2、反复重启服务端可能会发生报错: address in use
 解决方法：
# 在最上面放一个
 from socket import SOL_SOCKET,SO_REUSEADDR
# 在bind上面放
 server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
  

3.当客户端异常断开的情况下 如何让服务端继续服务其他客人
	
链接循环
"""
如果在windows客户端异常处理退出之后服务端就会直接报错
  mac服务端会有一段时间反复接收空消息延迟报错	
  	处理方式:异常处理、空消息判断
while True:
    sock, addr = server.accept()
    while True:
        try:
            data = sock.recv(1024)  # 获取别人说什么
            if len(data) == 0:
                break
            print(f'来自于客户端{addr}的消息:', data.decode('utf8'))  # 解码别人说的啥
            msg = input('请输入发送给客户端的消息:').strip()
            sock.send(msg.encode('utf8'))  # 回复别人的话 因为基于网络传输 使用二进制编码
        except BaseException:
            break
"""

回到顶部

半连接池

server.listen(5)  # 半连接池
py文件默认只能同时只能运行一次，如果想要单独分开运行多次：
Edit Configuration选择all

当有多个客户端来链接的情况下 我们可以设置等待数量(不考虑并发问题)
假设服务端只有一个人的情况下

在测试半连接池的时候 可以不用input获取消息 直接把消息写死即可 
# 半连接池
  设置最大等待人数 >>>:  节省资源，提升效率

回到顶部

黏包现象

# 服务端
import socket

server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)

sock, addr = server.accept()
data = sock.recv(1024)
print(data)
data1 = sock.recv(1024)
print(data1)
data2 = sock.recv(1024)
print(data2)


# 客户端
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

client.send(b'say')
client.send(b'good')
client.send(b'bye')

1.服务端连续执行三次recv
2.客户端连续执行三次send
问题:服务端一次性接收到了客户端三次的消息 该现象称为"黏包现象"
    
# TCP协议的特点
	将数据量比较小并且时间间隔比较短的数据整合到一起发送,并且还会受制于recv括号内的数字大小
    流式协议:跟水流一样不间断
        
 就是因为我们不知道recv括号不知道要接收多大的数据，使用才会出现黏包问题，那么我们只要能够判断接收的数据具体大小，就可以避免黏包问题

回到顶部

struct模块

# 能够精准确定数据的大小
使用struct模块
import struct

data = 'say good bye'
print(len(data))  # 数据真实的长度(bytes) 12
res = struct.pack('i', len(data))  # 将数据打包成固定的长度 i是固定的打包模式
print(len(res))  # 打包之后长度为(bytes) 4     报头

real_len = struct.unpack('i', res)
print(real_len)  # (12,) 根据固定长度的报头 解析出真实数据的长度

data1 = 'talking to the moon'
print(len(data1))  # 数据真实的长度(bytes) 19
res1 = struct.pack('i', len(data1))  # 将数据打包成固定的长度 i是固定的打包模式
print(len(res1))  # 打包之后长度为(bytes) 4     报头

real_len1 = struct.unpack('i', res1)
print(real_len1)  # (19,) 根据固定长度的报头 解析出真实数据的长度

  pack可以将任意长度的数字打包成固定长度
  unpack可以将固定长度的数字解包成打包之前数据真实的长度

解决黏包问题

"""
解决黏包问题初级版本
    客户端
        1.将真实数据转成bytes类型并计算长度
        2.利用struct模块将真实长度制作一个固定长度的报头
        3.将固定长度的报头先发送给服务端 服务端只需要在recv括号内填写固定长度的报头数字即可
        4.然后再发送真实数据
    
    服务端
        1.服务端先接收固定长度的报头
        2.利用struct模块反向解析出真实数据长度
        3.recv接收真实数据长度即可
"""
# 问题1:struct模块无法打包数据量较大的数据 就算换更大的模式也不行
# res = struct.pack('i', 12313213123)
# print(res)
# 问题2:报头能否传递更多的信息  比如电影大小 电影名称 电影评价 电影简介

'''终极解决方案:字典作为报头打包 效果更好 数字更小'''
data_dict = {
    'file_name': 'xxx老师教学.avi',
    'file_size': 123132131232342342423423423423432423432,
    'file_info': '内容很精彩 千万不要错过',
    'file_desc': '一代神作 私人珍藏'
}
import json
data_json = json.dumps(data_dict)
print(len(data_json.encode('utf8')))  # 真实字典的长度  228
res = struct.pack('i', len(data_json.encode('utf8')))
print(len(res))


"""
黏包问题终极方案
    客户端 
        1.制作真实数据的信息字典(数据长度、数据简介、数据名称)
        2.利用struct模块制作字典的报头
        3.发送固定长度的报头(解析出来是字典的长度)
        4.发送字典数据
        5.发送真实数据     
    服务端
        1.接收固定长度的字典报头
        2.解析出字典的长度并接收
        3.通过字典获取到真实数据的各项信息
        4.接收真实数据长度
"""

黏包代码实战

# 接收方
import socket
import struct
import json

server = socket.socket()
server.bind(('127.0.0.1', 8081))
server.listen(5)

sock, addr = server.accept()
# 1.接收固定长度的字典报头
data_dict_head = sock.recv(4)
# 2.根据报头解析出字典数据的长度
data_dict_len = struct.unpack('i', data_dict_head)[0]
# 3.接收字典数据
data_dict_bytes = sock.recv(data_dict_len)
data_dict = json.loads(data_dict_bytes)  # 自动解码再反序列化

# 4.获取真实数据的各项信息
方法一:
total_size = data_dict.get('file_size')
with open(data_dict.get('file_name'), 'wb') as f:
   f.write(sock.recv(total_size))

方法二:
'''接收真实数据的时候 如果数据量非常大 recv括号内直接填写该数据量 不太合适 我们可以每次接收一点点 反正知道总长度'''
total_size = data_dict.get('file_size')
recv_size = 0
with open(data_dict.get('file_name'), 'wb') as f:
    while recv_size < total_size:
        data = sock.recv(1024)
        f.write(data)
        recv_size += len(data)
        print(recv_size)

# 发送方
import socket
import os
import struct
import json

client = socket.socket()
client.connect(('127.0.0.1', 8081))

'''任何文件都是下列思路 图片 视频 文本 ...'''
# 1.获取真实数据大小
file_size = os.path.getsize(r'/Users/jiboyuan/PycharmProjects/day36/xx老师合集.txt')
# 2.制作真实数据的字典数据
data_dict = {
    'file_name': '有你好看.txt',
    'file_size': file_size,
    'file_desc': '内容很长 准备好吃喝 我觉得营养快线挺好喝',
    'file_info': '这是我的私人珍藏'
}
# 3.制作字典报头
data_dict_bytes = json.dumps(data_dict).encode('utf8')
data_dict_len = struct.pack('i', len(data_dict_bytes))
# 4.发送字典报头
client.send(data_dict_len)  # 报头本身也是bytes类型 我们在看的时候用len长度是4
# 5.发送字典
client.send(data_dict_bytes)
# 6.最后发送真实数据
with open(r'/Users/jiboyuan/PycharmProjects/day36/xx老师合集.txt', 'rb') as f:
    for line in f:  # 一行行发送 和直接一起发效果一样 因为TCP流式协议的特性
        client.send(line)
import time
time.sleep(10)