socket套接字简介

由于操作OSI七层是所有cs架构的程序都需要经历的过程 所以有固定的模块
  socket套接字是一门技术
  socket模块>>>:提供了快捷方式 不需要自己处理每一层

socket模块

cs架构的软件无论是在编写还是运行
	都应该先考虑服务端 
服务端与客户端首次交互
	一边是recv那么另一边必须是send  两边不能相同 
   '''一边发送另一半就得先接收'''

服务端

import socket

server = socket.socket()	# 创建对象
server.bind(('127.0.0.1', 8080))	# 绑定地址 端口

server.listen(5)        # 半连接池
sock, addr = server.accept()    # 等待并接收消息 没有就在原地等待（程序阻塞）
print(addr)

data = sock.recv(1024)      # 接收 bytes类型需解码
print('收到来自客户端的消息:' + data.decode('utf8'))
sock.send('萨瓦迪卡客户端'.encode('utf8'))    # 发送给客户端 需编码成bytes类型
sock.close()
server.close()

客户端

import socket

client = socket.socket()	# 创建对象
client.connect(('127.0.0.1', 8080))  # 和服务端地址相同

client.send(b'qiubabi munieniu')	# 发送给服务端
data = client.recv(1024)
print('收到来自服务端的消息:' + data.decode('utf8'))

client.close()

通信循环

将数据交换的代码循环
'''能够多次收发'''
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'))

代码优化及链接循环

1.发送消息不能为空
	统计长度并判断即可
2.反复重启服务端可能会报错>>>:address in use
  这个错在苹果电脑报的频繁 windows频率较少
  from socket import SOL_SOCKET,SO_REUSEADDR
  server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) # 在bind前加
3.链接循环
  """
  如果是windows 客户端异常退出之后服务端会直接报错
  	处理方式
  		异常处理
  如果是mac或linux 服务端会接收到一个空消息
  	处理方式
  		len判断
  """
  客户端如果异常断开 服务端代码应该重新回到accept等待新的客人

# 目前我们的服务端只能实现一次服务一个人 不能做到同事服务多个 学了并发才可以实现

服务端

import socket
from socket import SOL_SOCKET, SO_REUSEADDR

server = socket.socket()
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) #就是它，在bind前加
server.bind(('127.0.0.1', 8080))
server.listen(5)

while True:
    sock, addr = server.accept()
    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

客户端

import socket

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

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

半连接池

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

# 半连接池
	设置的最大等待人数  >>>:  节省资源 提高效率

黏包问题

# TCP协议的特点
	会将数据量比较小并且时间间隔比较短的数据整合到一起发送
  并且还会受制于recv括号内的数字大小(核心问题!!!)
  流式协议:跟水流一样不间断
"""
问题产生的原因其实是因为recv括号内我们不知道即将要接收的数据到底多大
如果每次接收的数据我们都能够精确的知道它的大小 那么肯定不会出现黏包
"""

服务端

import socket

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

conn, addr = server.accept()
data1 = conn.recv(5)
print(data1)
data2 = conn.recv(5)
print(data2)
data3 = conn.recv(5)
print(data3)

客户端

import socket

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

client.send(b'1234567')
client.send(b'abcde')
client.send(b'hhhhh')

结果

# 打印结果
b'12345'
b'67abc'
b'dehhh'

解决黏包问题

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

# struct模块    
import struct

data1 = 'qiubabimunieniu'
print(len(data1))   # 15
res1 = struct.pack('i', len(data1)) # 第一个参数为格式 写i就行
print(len(res1))    # 4
ret1 = struct.unpack('i', res1)
print(ret1)     # (15,)    

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

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

最终方案

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


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

服务端

import json
import os.path
import socket
import struct

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

data_dict = {
    'file_name': 'xyyyhtl.txt',
    'file_desc': 'what fuck',
    '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_pack_header = struct.pack('i', len(dict_bytes))
# 2.发送报头
sock.send(dict_pack_header)
# 3.发送字典
sock.send(dict_bytes)
# 4.发送真实数据
with open(r'04 struct模块.py', 'rb') as f:
    for line in f:
        sock.send(line)

客户端

import json
import socket
import struct

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)