• 今日内容详细
  • socket
    • socket套接字简介
    • socket模块
      • 服务端
      • 客户端
    • 通信循环
      • 服务端
      • 客户端
    • 链接循环
    • 半连接池
      • 概念
      • 产生半连接的两种情况
  • 黏包问题
    • 多次发送被并为一次
      • TCP协议的特点
      • 黏包问题原因
    • 解决黏包问题
      • struct模块
      • 思路
    • 代码演示
      • 服务端
      • 客户端

socket

socket套接字简介

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

"""
socket是最底层的原理，很多框架都封装了
"""

Socket并不属于TCP/IP协议簇，它只是一个编程接口，即对TCP/IP的封装和应用，简单理解TCP/IP看看作一个函数，而Socket用来进行调用，Socket可在网络中对两个程序建立通信通道，Socket可分为两个基本模块，一个服务端一个客户端，链接后进行通信。

socket模块

cs架构的软件无论是在编写还是运行都应该先考虑服务端

服务端

import socket


server = socket.socket()  # 第一步，创建一个socket对象（server），准备好联入网络的协议
"""
通过查看源码得知 
括号内不写参数默认就是基于网络的遵循TCP协议的套接字
"""
server.bind(('127.0.0.1', 8080))   # 第二步，选择地址与端口号（以元组的形式）
"""
服务端应该具备的特征
    固定的地址
    ...  
127.0.0.1是计算机的本地回环地址 只有当前计算机本身可以访问
"""
server.listen(5)  # 第三步，设置半连接池,最低为0,成功链接入网络
"""
半连接池(暂且忽略 先直接写 后面讲)
"""
sock, addr = server.accept()  # 等待用户来发起会话，若无用户便会造成程序阻塞(接收客户端连接，获得sock连接 和 addr客户端地址。)
"""
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，两边不能相同，否则就'冷战'了
'''

通信循环

1.先解决消息固定的问题
	利用input获取用户输入
2.再解决通信循环的问题
	将双方用于数据交互的代码循环起来

服务端

import socket
from socket import SOL_SOCKET,SO_REUSEADDR
server = socket.socket()  # 创建一个socket对象（server）
  
    # -------------------------------------
    #在重启服务器的时候可能会遇到的BUG(mac居多)，windows频率较少
    # 加上他就可以防止重启报错了(注意位置)
    # -------------------------------------
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

server.bind(('192.168.1.8', 8080))  # 给socket对象（server）绑定ip和端口号（以元组的形式）
server.listen(5)  # 设置半连接池,最低为0
sock, addr = server.accept()  # 接收客户端连接，获得sock连接 和 addr客户端地址。
while True:
	data = sock.recv(1024)  # 获取客户端发送的消息
	print(data.decode('utf8')) # 打印接收到的数据，由于传输的时候是二进制所以需要进行解码
	msg = input('要发送的消息: ').strip()
	sock.send(msg.encode('utf8'))  # 服务端发送消息给客户端

    # sock.close()  # 断开服务端到客户端的连接
    # server.close()  # 关闭服务端

客户端

import socket

client = socket.socket()  # 创建一个socket对象（client）
client.connect(('192.168.1.8', 8080))  # 根据ip和端口连接服务端（元组的形式）,主动发起连接
while True:
	msg = input('要发送的消息: ').strip()  # 获取要发送给服务端的消息
	if len(msg) == 0: continue  # 避免消息为空时，造成双方等待
	client.send(msg.encode('utf8'))  # 将消息先编码后在发送给服务端
	data = client.recv(1024)  # 获取服务端发送的消息
	print(data.decode('utf8'))  # 打印接收到的数据，由于传输的时候是二进制所以需要进行解码
	client.close()  # 断开连接,关闭客户端

链接循环

"""
  如果是windows 客户端异常退出之后服务端会直接报错
  	处理方式
  		异常处理
  如果是mac或linux 服务端会接收到一个空消息
  	处理方式
  		len判断
"""
# linux、mac断开链接时不会报错，会一直返回空(b‘’)
# 客户端如果异常断开,服务端代码应该重新回到accept等待新的客人

# 目前我们的服务端只能实现一次服务一个人,不能做到同事服务多个 

import socket
from socket import SOL_SOCKET, SO_REUSEADDR

server = socket.socket()  # 创建一个socket对象（server）

  # -------------------------------------
  # 加上他就可以防止重启报错了(注意位置)
  # -------------------------------------
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

server.bind(('192.168.1.8', 8080))  # 给socket对（server）绑定ip和端口号（以元组的形式）
server.listen(5)  # 设置半连接池,最低为0
while True:
	sock, addr = server.accept()  # 接收客户端连接，获得sock连接 和 addr客户端地址。

	while True:
		try:
			data = sock.recv(1024)  # 获取客户端发送的消息
			print(data.decode('utf8'))  # 打印接收到的数据，由于传输的时候是二进制所以需要进行解码
			msg = input('要发送的消息: ').strip()
			sock.send(msg.encode('utf8'))  # 服务端发送消息给客户端
		except BaseException:
			break # 客户端如果异常断开 服务端代码应该重新回到accept等待新的客人

# sock.close()  # 断开服务端到客户端的连接
# server.close()  # 关闭服务端

半连接池

概念

当服务器在响应了客户端的第一次请求后会进入等待状态，会等客户端发送的ack信息，这时候这个连接就称之为半连接。

半连接池其实就是一个容器，系统会自动将半连接放入这个容器中，可以避免半连接过多而保证资源耗光。

产生半连接的两种情况

1.客户端无法返回ACK信息
2.服务器来不及处理客户端的连接请求


设置的最大等待人数  >>>:  节省资源 提高效率
server.listen(5)  # 指定5个等待席位

'''限制的是同一时刻的请求数，而非连接数'''

# py文件默认同一时间只能运行一次，如果想单独分开运行多次

黏包问题

多次发送被并为一次

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''
"""

黏包现象只发生在tcp协议中

TCP协议的特点

# 会将数据量比较小并且时间间隔比较短的数据整合到一起发送
# 并且还会受制于recv括号内的数字大小(核心问题)
  流式协议:跟水流一样不间断

黏包问题原因

1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点
2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

# 粘包是接收长度没对上导致的
	控制recv接收的字节数与之对应(你发多少字节我收多少字节)
	在很多情况下并不知道数据的长度，服务端不能写死

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

解决黏包问题

方向:精准获取数据的大小

struct模块

struct 模块可以将任意大小的数字转换成一个固定长度(可选择)的 bytes, 这个原理类似于 hash 算法, 不论内容多大, 最终的 hash 值长度不变, 不同的是 hash 算法是不可逆的, 而且传入的原材料可以是文本、字符串等许多数据类型, struct 可以反解出原来的数据

ps : struct 模块只能转换数字, 不能转换其他的数据类型

import struct

data1 = 'hello world!'
print(len(data1))  # 12
res1 = struct.pack('i', len(data1))  # 第一个参数是格式 写i就可以了
print(len(res1))  # 4
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,)

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

这里利用struct模块的 struct.pack() struct.unpack() 方法来实现打包(将真实数据长度变为固定长度的数字)解包(将该数字解压出打包前真实数据的长度)

    pack unpack模式参数对照表(standard size 转换后的长度)

思路

# 服务器端
    先制作一个发送给客户端的字典
    制作字典的报头
    发送字典的报头
    发送字典
    再发真实数据
    
# 客户端
    先接收字典的报头
    解析拿到字典的数据长度
    接收字典
    从字典中获取真实数据的长度
    循环获取真实数据

ps:为什么要多加一个字典
  pack打包的数据长度(的长度)有限，字典再打包会很小(长度值也会变很小)(120左右)
  可以携带更多的描述信息

代码演示

服务端

import socket
from socket import SOL_SOCKET, SO_REUSEADDR
import os
import json
import struct

server = socket.socket()  # 创建一个socket对象（server）

server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)  # 防止重启报错了

server.bind(('127.0.0.1', 9000))  # 给socket对象（server）绑定ip和端口号（以元组的形式）
server.listen(5)  # 设置半连接池,最低为0
sock, addr = server.accept()  # 接收客户端连接，获得sock连接 和 addr客户端地址。

# 1.先制作一个字典(可以放入一些描述性的信息)
data_dict = {
      'file_name': '11.jpg',
      'file_title': '壁纸',
      'file_size': os.path.getsize(r'D:\pythonproject\test\11.jpg') # 可以改为自己的文件地址
  }
  # 2.制作字典报头
data_dict_json_str = json.dumps(data_dict)  # 转化成字符串
data_dict_json_str_bytes = data_dict_json_str.encode('utf8')  # 将字符串编码
data_dict_package = struct.pack('i', len(data_dict_json_str_bytes))  # 以i模式打包,打包成4个字节
  # 3.发送报头
sock.send(data_dict_package)  # 服务端将字典发送给客户端
  # 4.发送字典
sock.send(data_dict_json_str_bytes)
  # 5.发送真实数据
with open(r'D:\pythonproject\test\11.jpg', 'rb') as f:
	for i in f:
		sock.send(i)
print('发送完成')

客户端

import socket
import struct
import json

client = socket.socket()  # 创建一个socket对象（client）
client.connect(('127.0.0.1', 9000))  # 根据ip和端口连接服务端（元组的形式）,主动发起连接

  # 1.先接收字典的报头
data_dict_package = client.recv(4)
  # 2.解析拿到字典的数据长度
data_dict_len = struct.unpack('i', data_dict_package)[0]
  # 3.接收字典数据
data_dict = client.recv(data_dict_len)
data_dict = data_dict.decode('utf8')
data = json.loads(data_dict)
  # 4.循环接收文件数据 不要一次性接收
recv_size = 0
with open('waa.jpg', 'wb') as f:
	while recv_size < data.get('file_size'):
		write_data = client.recv(1024)
		recv_size += len(write_data)
		f.write(write_data)

recv括号内的数字尽量不要写太大 ,1024 \2048\ 4096足够了,字典数据很难突破上面的数值,所以针对大文件的接收应该采用循环的形式一次接受一点点