Python---socket模块使用

socket模块

socket套接字简介

编写一个cs架构的程序，实现数据交互，需要编写代码操作OSI七层，相当的复杂。由于操作OSI七层是所有cs架构的程序都需要经历的过程，所以有固定的模块。socket套接字是一门技术，socket模块提供了快捷方式，不需要自己处理每一层。

socket模块应用

cs架构的软件无论是在编写还是运行，都应该先考虑服务端，就想是开一个店，得现有店面才能接待客人。

服务端

import socket  # 导入socket模块

server = socket.socket()  # 创建套接字对象，相当于买手机
"""
通过查看源码得知 
括号内不写参数默认就是基于网络的遵循TCP协议的套接字
"""
server.bind(('127.0.0.1', 8080))  # 将ip地址和端口号绑定到套接字 插电话卡
"""
服务端应该具备的特征
    固定的地址
127.0.0.1是计算机的本地回环地址 只有当前计算机本身可以访问
"""
server.listen(5)  # 开机
"""
半连接池---设置的最大等待人数可以节省资源，提高效率
"""
sock, addr = server.accept()  # 等待客户端的消息，获取客户端的对象和地址，相当于等待并接电话
"""
listen和accept对应TCP三次握手服务端的两个状态
"""
print(addr)  # 客户端的地址
data = sock.recv(1024)  # 获取客户端的消息 听别人说话
print(data.decode('utf8'))
sock.send('你好啊'.encode('utf8'))  # 回复发送客户端的消息回复别人说的话
"""
recv和send接收和发送的都是bytes类型的数据
"""
sock.close()  # 挂电话
server.close()  # 关机

客户端

import socket

client = socket.socket()  # 产生一个socket对象
client.connect(('127.0.0.1', 8080))  # 根据服务端的地址链接

client.send(b'hello sweet heart!!!')  # 给服务端发送消息
data = client.recv(1024)  # 接收服务端回复的消息
print(data.decode('utf8'))

client.close()  # 关闭客户端

'''
服务端与客户端首次交互
	一边是recv那么另一边必须是send  两边不能相同 否则就'冷战'了
'''

服务端与客户端首次交互，一边是recv那么另一边必须是send，两边不能相同，否则两边都在等待对方发来的消息直接卡住。

半连接池

在py文件默认同一时间只能运行一次，如果想单独分开运行多次 就需要用半连接池。

作用：设置的最大等待人数可以节省资源，提高效率。

server.listen(5)  

通信循环

解决消息固定的问题，这个简单，直接利用input方法获取用户输入的消息即可。为了能让服务端和客户端一直可以互相发送消息，我们需要解决通信循环的问题，通讯循环嘛，主要就是循环，循环可以利用while循环实现。

服务端

while True:
    data = sock.recv(1024)  # 听别人说话
    print(data.decode('utf8'))
    msg = input('请回复消息>>>:').strip()
    sock.send(msg.encode('utf8'))  # 回复别人说的话

客户端

while True:
    msg = input('请输入你需要发送的消息>>>:').strip()
    client.send(msg.encode('utf8'))  # 给服务端发送消息
    data = client.recv(1024)  # 接收服务端回复的消息
    print(data.decode('utf8'))

代码优化及链接循环

我们可以统计发生的长度进行判断，避免发生信息为空。

# 客户端
while True:
    msg = input('请输入你需要发送的消息>>>:').strip()
    # 用户如果什么都不输 直接回车 那么不该往下走
    if len(msg) == 0:
        continue
    client.send(msg.encode('utf8'))  # 给服务端发送消息
# 服务端
msg = input('请回复消息>>>:').strip()
            if len(msg) == 0:
                msg = '太忙 暂无消息'

反复重启服务端可能会报错，address in use。这个错在苹果电脑报的频繁，windows频率较少。我们可以采用下列代码解决反复重启报错的情况。

from socket import SOL_SOCKET,SO_REUSEADDR
  server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) # 在bind前加

在windows上客户端异常退出后服务端会直接报错，我们可以采取异常处理的方法，如果是mac或linux系统服务端会接收到一个空信息，我们可以采用len长度判断的方法解决。

代码演示

    while True:
        try:
            data = sock.recv(1024)  # 听别人说话
            if len(data) == 0:
                break
            print(data.decode('utf8'))
            msg = input('请回复消息>>>:').strip()
            if len(msg) == 0:
                msg = '太忙 暂无消息'
            sock.send(msg.encode('utf8'))  # 回复别人说的话
        except Exception:
            break
'''
 客户端如果异常断开 服务端代码应该重新回到accept等待新的客人
 '''

黏包问题

TCP协议的特点是会将数据量比较小并且时间间隔比较短的数据整合到一起发送，并且还会受制于recv括号内的数字大小。因为tcp协议是流式协议，跟水流一样不间断。

data1 = conn.recv(1024)
print(data1)
data2 = conn.recv(1024)
print(data2)
data3 = conn.recv(1024)
print(data3)

client.send(b'hello')
client.send(b'jason')
client.send(b'kevin')
"""
三次打印的结果
  b'hellojasonkevin'
  b''
  b''
"""
# 问题：传入的3次数据被合成一个

问题产生的原因其实是因为recv括号内我们不知道即将要接收的数据到底多大，如果每次接收的数据我们都能够精确的知道它的大小，那么肯定不会出现黏包。

思路：精准的知道数据量多大，那么黏包问题就自动解决了。

解决黏包问题

可以利用struct模块精准的获取数据的大小。

思路:
1.先将真实数据打包成固定长度的包
2.将固定长度的包先发给对方
3.对方接收到包之后再解包获取真实数据长度
4.接收真实数据长度

import struct

data1 = 'hello world!'
print(len(data1))  # 12
# pack可以将任意长度的数字打包成固定长度
res1 = struct.pack('i', len(data1))  # 第一个参数是格式 写i就可以了
print(len(res1))  # 4
#  unpack可以将固定长度的数字解包成打包之前数据真实的长度
ret1 = struct.unpack('i', res1)
print(ret1)  # (12,)

data2 = 'hello baby baby baby baby baby baby baby baby'
print(len(data2))  # 45
res2 = struct.pack('i', len(data2))
print(len(res2))  # 4
ret2 = struct.unpack('i', res2)
print(ret2)  # (45,)

小问题:负责打包的方法数据量如果特别巨大是无法打包的。

终极解决方案：利用字典存储数据，不但有数据的长度，还可以携带额外的数据。

发送端的思路：

 1.先构造一个字典 
        内部存档了真实数据相关的信息
            大小 名称 简介 ...
2.对字典做打包处理
3.将固定长度的数据(字典)发送给对方
4.发送真实的字典数据
5.发送真实的真正数据

接收端的思路：

1.先接收固定长度的字典包
2.解析出字典的真实长度
3.接收字典数据
4.从字典数据中解析出各种信息
5.接收真实的数据

代码实现：

# 服务端
import socket
import os
import struct
import json


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

conn, addr = server.accept()

data_dict = {
    'file_name':'xxx刺激.txt',
    'file_desc':'封控一个多月了',
    'file_size':os.path.getsize(r'04 struct模块.py')
}
# 1.先打包字典
dict_json_str = json.dumps(data_dict)
dict_bytes = dict_json_str.encode('utf8')
dict_package_header = struct.pack('i', len(dict_bytes))
# 2.发送报头
conn.send(dict_package_header)
# 3.发送字典
conn.send(dict_bytes)
# 4.发送真实数据
with open(r'04 struct模块.py', 'rb') as f:
    for line in f:
        conn.send(line)

# 客户端
import socket
import struct
import json

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

# 1.先接收固定长度的字典的报头
dict_header_len = client.recv(4)
# 2.解析出字典的真实长度
dict_real_len = struct.unpack('i', dict_header_len)[0]
# 3.接收字典数据
dict_data_bytes = client.recv(dict_real_len)
dict_data = json.loads(dict_data_bytes)
print(dict_data)
# 4.循环接收文件数据 不要一次性接收
recv_size = 0
with open(dict_data.get('file_name'),'wb') as f:
    while recv_size < dict_data.get('file_size'):
        data = client.recv(1024)
        recv_size += len(data)
        f.write(data)