socket模块实现网络编程及struct模块解决黏包问题

一、socket模块
二、socket代码简介
三、socket代码优化
四、半连接池的概念
五、黏包现象
- 什么是黏包
- 黏包现象产生的原因
六、struct模块及解决黏包问题的流程
七、粘包代码实战
- 服务端
- 客户端
八、UDP协议（了解）

一、socket模块

1、简介

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

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

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

ps：socket也叫套接字

2、基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

3、基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

二、socket代码简介

服务端代码

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为本地回环地址 只有自己的电脑可以访问，8080为端口号

# 3.设立半连接池(后面会讲)

server.listen(5)

# 4.等待接客

sock, addr = server.accept()  # return 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对象指定类型和协议

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()

三、socket代码优化

1.聊天内容自定义

针对消息采用input获取

2.让聊天循环起来

将聊天的部分用循环包起来（三次握手的代码开始包起来）

3.用户输入的消息不能为空

本质其实是两边不能都是recv或者send 一定是一方收一方发

4.服务端多次重启可能会报错

Address already in use

主要是mac电脑会报

方式1:改端口号

方式2:

#加入一条socket配置，重用ip和端口

import socket

from socket import SOL_SOCKET,SO_REUSEADDR

sk = socket.socket()

sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加

sk.bind(('127.0.0.1',8898))  #把地址绑定到套接字

sk.listen()          #监听链接

conn,addr = sk.accept() #接受客户端链接

ret = conn.recv(1024)   #接收客户端信息

print(ret)              #打印客户端信息

conn.send(b'hi')        #向客户端发送信息

conn.close()       #关闭客户端套接字

sk.close()        #关闭服务器套接字(可选)

5.当客户端异常断开的情况下如何让服务端继续服务其他客人?

windows服务端会直接报错

mac服务端会有一段时间反复接收空消息延迟报错

处理方式：使用异常处理、空消息判断，对上面的情况进行判断并给出解决方案

服务端代码：

import socket

from socket import SOL_SOCKET, SO_REUSEADDR

server = socket.socket()

server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

server.bind(('127.0.0.1', 8081))

server.listen(5)

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

客户端代码：

import socket

client = socket.socket()

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

while True:

    msg = input('请输入您想要发送给服务端的消息>>>:').strip()

    # 把发送的信息设置成自定义

    if len(msg) == 0:

        print('不能发送空消息')

        continue

    client.send(msg.encode('utf8'))

    data = client.recv(1024)

    print('来自于服务端发送过来的消息>>>:', data.decode('utf8'))

四、半连接池的概念

server.listen(5) # 半连接池

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

假设服务端只有一个人的情况下

比如上面我们半连接池设置成五个，在优化后的代码中，由于用while循环包裹了代码，当我们在运行代码的时候可以这样理解，第一个客户端就会直接跟服务端进行交互，除此之外还有五个客户端可以排队，但是发出去的信息服务端那边暂时不会处理，要等到第一个客户端处理结束断开连接才会根据先后顺序依次往后处理

在测试半连接池的时候可以不用input获取消息直接把消息写死即可

五、黏包现象

什么是黏包

1.服务端连续执行三次recv(字节数需要大一些)

import socket

server = socket.socket()

server.bind(('127.0.0.1', 8081))

server.listen(5)

sock, addr = server.accept()

data1 = sock.recv(1024)

print(data1)

data2 = sock.recv(1024)

print(data2)

data3 = sock.recv(1024)

print(data3)

sock.close()

server.close()

2.客户端连续执行三次send

import socket

client = socket.socket()

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

client.send(b'hello kevin')

client.send(b'jason say hei')

client.send(b'jerry say goodbye')

问题:服务端一次性接收到了客户端三次的消息该现象称为"黏包现象"

黏包现象产生的原因

1.不知道每次的数据到底多大

2.TCP也称为流式协议:数据像水流一样绵绵不绝没有间隔(TCP会针对数据量较小且发送间隔较短的多条数据一次性合并打包发送)

在知道了产生的原因后我们可以想到避免黏包现象的核心思路\关键点在于如何明确即将接收的数据具体有多大

ps:如何将长度变化的数据全部制作成固定长度的数据

六、struct模块及解决黏包问题的流程

struct模块

在处理黏包现象之前需要学习一个新模块：struct模块

该模块可以把一个类型，如数字，转成固定长度的bytes（当然了，有长度限制）

import struct

info = b'hello big baby'

print(len(info))  # 数据真实的长度(bytes)  14

res = struct.pack('i', len(info))  # 将数据打包成固定的长度 i是固定的打包模式

print(len(res))  # 打包之后长度为(bytes)   4           报头

real_len = struct.unpack('i', res)

print(real_len)  # (14,)             根据固定长度的报头 解析出真实数据的长度

desc = b'hello my baby I will take you to play big ball'

print(len(desc))  # 数据真实的长度(bytes)  46

res1 = struct.pack('i', len(desc))

print(len(res1))  # 打包之后长度为(bytes)  4           报头

real_len1 = struct.unpack('i', res1)

print(real_len1)  # (46,)              根据固定长度的报头 解析出真实数据的长度

这里我们发现struct模块可以把对应的数据类型打包成固定的二进制长度然后还可以解压回去。

解决黏包问题初级版本

客户端

1.将真实数据转成bytes类型并计算长度

2.利用struct模块将真实长度制作一个固定长度的报头

3.将固定长度的报头先发送给服务端服务端只需要在recv括号内填写固定长度的报头数字即可

4.然后再发送真实数据

服务端

1.服务端先接收固定长度的报头

2.利用struct模块反向解析出真实数据长度

3.recv接收真实数据长度即可

解决过程中遇到的问题

问题1:

struct模块无法打包数据量较大的数据，就算换更大的模式也不行

问题2:

报头能否传递更多的信息比如电影大小电影名称电影评价电影简介

解决黏包问题终极解决方案

字典作为报头打包效果更好数字更小

import struct

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)

八、UDP协议（了解）

1.UDP服务端和客户端'各自玩各自的'

2.UDP不会出现多个消息发送合并