Socket - 套接字编程

只要涉及到远程数据交互必须要操作OSI七层模型，那么每层都需要相应的程序去操作，现在就需要一个模块去操作，直接实现；

Socket是处于应用层和传输层之间的抽象层，Socket并不是一个单独的层，在我们设计程序软件的时候，它会让编程变的更简单，我们大量用的都是通过socket实现的；

Socket的作用显而易见，TCP和UDP比喻成小弟，socket是大哥，那么下面的协议（TCP/UDP）不需要我们去管，这样暴露出来的只有Socket接口，Socket自动的去组织数据，来符合指定的协议标准；

Socket 通信流程图

Socket基于TCP/IP协议的面向连接的通信，分为客户端和服务端，必须先启动服务端，然后再启动客户端去链接服务端；

Socket模块

socket（）方法

客户端和服务端的入口，默认就是基于网络的TCP协议传输；

部分参数

套接字家族：

• AF_UNIX：本机通信
• AF_INET：TCP/IP协议，使用IPV4，基于网络传输
• AF_INET6：TCP/IP协议，使用IPV6，基于网络传输

类型分类（type）

• SOCK_STREAM：TCP协议（默认采用，流式协议）
• SOCK_DGRAM：UDP协议
• SOCK_RAW：原始套接字

proto参数是协议标志，默认为0，原始套接字需要指定值

bind（）方法

绑定函数的作用就是为调用socket()函数产生的套接字分配一个本地协议地址，建立地址与套接字的对于关系；

# 源码
def bind(self, address: Union[_Address, bytes]) -> None: ...
# 参数
address: Union[_Address, bytes]
address：要接收的数据类型集合
->：返回什么（返回值）
# 示例bind((ip,端口))
server.bind(('127.0.0.1', 8080))  # 绑定ip和端口

listen（）方法

监听函数，作用是建立半连接池，规定最大连接数，在windows系统下如果客户端数量超过半连接池规定的数量会报错；

server.listen(5)  # 半连接池  
# 如果服务端正在和一个客户端做交互，那么半连接池就规定了，还可以服务几个客服端;
# 类似于，餐厅门口可以让顾客坐的凳子，满了就不能坐了

accept（）方法

作用就是使服务器接受客户端的连接请求；

运行服务端，会在此监听，等待请求；

def accept(self) -> Tuple[socket, _RetAddress]: ...
# 返回一个元组，元组包括socket对象和地址信息
"""
accept() -> (socket object, address info)

        Wait for an incoming connection.  Return a new socket
        representing the connection, and the address of the client.
        For IP sockets, the address info is a pair (hostaddr, port).
        """

accept（）函数返回值：sock、addr

• sock：用于操作服务端和客户端连接的双向通道的媒介

• addr：客户端的地址

• sock.recv()：接收消息，返回bytes类型数据

def recv(self, bufsize: int, flags: int = ...) -> bytes: ...
# 示例
sock.recv(1024) # 接收客户端发送的消息，一次接收1024bytes

• sock.send()：发送消息，返回int类型数据

def send(self, data: bytes, flags: int = ...) -> int: ...
# 示例
sock.send(b'HammerZe')

connect() 方法

作用是TCP客户端连接服务器

def connect(self, address: Union[_Address, bytes]) -> None: ...

# 示例
# 格式：connect((ip,port)),里面是tuple类型
client.connect(('127.0.0.1', 8080))

close（）方法

关闭套接字，并立即返回到进程；

sock.close()  
server.close() 

服务端客户端对比

编写小妙招：

服务端	客户端	对比
server=socket.socket()	client=socket.socket()	开头必须
server.bind((ip,port))	client.connect((ip,port))	连接必须
server.listen(n) # 半连接池		服务端
sock，addr = server.accept() # 获取客户端请求，返回sock，addr（客户端地址）		服务端
sock.recv(1024) # 服务端接收内容，1024为size	client.send(bytes) # 客户端发送bytes类型数据	服务端和客户端相对
sock.send(bytes) # 服务端发送bytes类型数据	client.recv(1024) # 客户端接收内容，1024为size	服务端和客户端相对
sock.close() # 关闭会话通道，断开连接		服务端
server.close() # 关闭套接字	client.close() # 关闭套接字	服务端和客户端

注意：服务端和客户端不可同时发数据（send），也不可同时收数据（recv）

简单案例

服务端

'''server.py'''
import socket

server = socket.socket()
# 建立连接
server.bind(('127.0.0.1', 8085))
# 半连接池
server.listen(5)
# 获取客户端请求
sock, address = server.accept()
print(address)
# 接收数据
data = sock.recv(1024)
print(data)
# 发送数据
sock.send(b"Hi,This is server-side!")
# 关闭通话
sock.close()
# 关闭套接字
server.close()

客户端

'''client.py'''
import socket

client = socket.socket()
# 建立连接
client.connect(('127.0.0.1', 8085))
# 发送数据
client.send(b"Hello guys,I'am HammerZe!")
# 接收数据
data = client.recv(1024)
print(data)
# 关闭套接字
client.close()

---

简易通信循环

光发一条消息不够过瘾是吧，如何通信循环，你侬我侬，如下：

服务端

import socket

server = socket.socket()
# 建立链接
server.bind(('127.1.1.1', 8086))
# 半连接池
server.listen(5)
# 监听
sock,address = server.accept()

while True:
    # 接收
    data = sock.recv(1024)
    print(data.decode('utf8'))
    # 发送
    to_cmsg = input('请输入发给客户端的内容>>>:').strip()
    sock.send(to_cmsg.encode('utf8'))
    

客户端

import socket

client = socket.socket()
# 获取ip和端口
client.connect(('127.1.1.1', 8086))
# 发送数据
while True:
    to_smsg = input('请输入发给服务端的内容>>>:').strip()
    client.send(to_smsg.encode('utf8'))
    # 接收数据
    data = client.recv(1024)
    print(data.decode('utf8'))

优化通信循环

优化内容：

• 解决，发空消息会停住，导致双方接收和发送混乱
• 解决Address already in use 报错（端口占用错误）
• 解决服务端启用，客户端主动重启报错，错误内容：远程主机强迫关闭了一个现有的连接，原因是没有走三次握手和四次挥手主动断开；

服务端

import socket
from socket import SOL_SOCKET,SO_REUSEADDR


server = socket.socket()
# 解决断开占用报错
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
# 建立链接
server.bind(('127.1.1.1', 8086))
# 半连接池
server.listen(5)
# 监听
while True:
    sock,address = server.accept()

    while True:
        try:
            # 接收
            data = sock.recv(1024)
            if len(data) ==0:continue
            print(data.decode('utf8'))
            to_cmsg = data+ b'server'
            sock.send(to_cmsg)
        except Exception:
            break

客户端

import socket

client = socket.socket()
# 获取ip和端口
client.connect(('127.1.1.1', 8086))
# 发送数据
while True:
    to_smsg = input('请输入发给服务端的内容>>>:').strip()
    if not to_smsg:
        print('不能输入空消息，请重新输入')
        continue
    client.send(to_smsg.encode('utf8'))
    # 接收数据
    data = client.recv(1024)
    print(data.decode('utf8'))

黏包问题

数据管道的数据没有被完全取出；TCP特性导致黏包，当数据量比较小 且时间间隔比较短，交互多次数据，那么TCP会自动打包成一个数据包发送；

情景一：如果交互的数据比规定接收的字节大，那么只会接收规定的字节大小，那么下次通信，继续传输上次没有传完的数据（互通管道，先进先出，TCP流式协议）；

情景二：如果交互的数据太小，比如想交互三次发三次hello，那么TCP会一次发完；

• 解决办法：调整规定接收size，调大或调小（不推荐）
• 使用Struct规定固定报头（推荐）

Struct 模块

使用Struct模块规定了报头的长度，通过服务端定制报头和客户端解析报头来获取真实数据的长度，从而接收真实的数据内容，解决黏包问题；

规定报头

案例

import struct
import json

info_dic = {
    'name':'Hammer',
    'age':18,
}
# 序列化
json_info_dic = json.dumps(info_dic)
# 真实长度
print(len(json_info_dic))  # 29

# 定制报头
herder = struct.pack('i',len(json_info_dic))
print(len(herder))  # 4
# 解析报头
parse_herder = struct.unpack('i',herder)[0]
print(parse_herder)  # 29

解决黏包问题

服务端

import socket
import subprocess
import json
import struct

server = socket.socket()
server.bind(('127.1.1.2', 8087))
server.listen(5)

while True:
    sock, address = server.accept()
    while True:
        data = sock.recv(1024)  # 接收cmd命令
        command_cmd = data.decode('utf8')
        sub = subprocess.Popen(command_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        res = sub.stdout.read() + sub.stderr.read()  # 结果可能很大
        # 1.制作报头
        data_first = struct.pack('i', len(res))
        # 2.发送报头
        sock.send(data_first)
        # 3.发送真实数据
        sock.send(res)

客户端

import socket
import struct

client = socket.socket()  
client.connect(('127.1.1.2', 8087))  

while True:
    msg = input('请输入cmd命令>>>:').strip()
    if len(msg) == 0:
        continue
    client.send(msg.encode('utf8'))
    # 1.先接收固定长度为4的报头数据
    recv_first = client.recv(4)
    # 2.解析报头
    real_length = struct.unpack('i',recv_first)[0]
    # 3.接收真实数据
    real_data = client.recv(real_length)
    print(real_data.decode('gbk'))