socket套接字

目录

• socket套接字简介
• socket模块
  • 服务端
  • 客户端
• 通信循环
• 代码优化及链接循环
• 黏包问题
• 解决黏包问题
  • struct模块

socket套接字简介

  由于操作OSI七层是所有cs架构的程序都需要经历的过程 所以有固定的模块
  socket套接字是一门技术
  socket模块>>>:提供了快捷方式 不需要自己处理每一层
"""
以后我们写软件连socket的影子都看不到 因为被封装起来
socket是最底层的原理 很多框架都封装了 其实我们不需要深入研究
"""

socket模块

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

服务端

import socket


server = socket.socket()  # 产生一个socket对象
"""
通过查看源码得知 
括号内不写参数默认就是基于网络的遵循TCP协议的套接字
"""
server.bind(('127.0.0.1', 8080))  # IP地址 端口 绑定地址（host,port）到套接字
"""
服务端应该具备的特征
固定的地址
    ...  
127.0.0.1是计算机的本地回环地址 只有当前计算机本身可以访问
"""
server.listen(5)  # 开始 TCP 监听。 括号内为操作系统可以挂起的最大连接数量。该值至少为 1，大部分应用程序设为 5 就可以了。
"""
半连接池
	设置的最大等待人数  >>>:  节省资源 提高效率)
"""
sock, addr = server.accept()  # 被动接受TCP客户端连接,(阻塞式)等待连接的到来
"""
listen和accept对应TCP三次握手服务端的两个状态
"""
print(addr)  # 客户端的地址
data = sock.recv(1024)  # 接收 TCP 数据，数据以字符串形式返回 括号内指定要接收的最大数据量
print(data.decode('utf8'))
sock.send('你好啊'.encode('utf8'))  # 发送 TCP 数据，将 string 中的数据发送到连接的套接字。
"""
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()  # 关闭客户端

'''
服务端与客户端首次交互 TCP协议是由客户端发起第一次握手
一边是recv那么另一边必须是send  两边不能相同 否则就'冷战'了
recv括号内的数字尽量不要写太大 1024 2048 4096足够了
字典数据很难突破上面的数值
所以针对大文件的接收应该采用循环的形式一次接受一点点
'''

通信循环

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

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.发送消息不能为空  # 在mac和linux系统中会被认为是客户端异常退出
	统计长度并判断即可
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等待新的客人

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

黏包问题

这个问题是因为TCP协议的特点，会将数据量比较小并且时间间隔比较短的数据整合到一起发送，并且还会受制于recv括号内的数字大小(核心问题!!!)

流式协议:跟水流一样不间断

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

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

解决黏包问题

困扰我们的核心问题是不知道即将要接收的数据多大，如果能够精准的知道数据量多大 那么黏包问题就自动解决了!

struct模块

pack()
pack(fmt, v1, v2, ...) 按照给定的格式(fmt)，把数据封装成字符串(实际上是类似于c结构体的字节流)
unpack()
unpack(fmt, string) 按照给定的格式(fmt)解析字节流string，返回解析出来的tuple
calcsize()
calcsize(fmt) 计算给定的格式(fmt)占用多少字节的内存

方向:精准获取数据的大小
  
# 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可以将固定长度的数字解包成打包之前数据真实的长度


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