【Python】简单socket数据收发服务器

阻塞式服务器

服务器（server.py）

# -*- coding: UTF-8 -*-

import socket
import sys
import os


class server:
    def __init__(self, ip, port):
        self.port = port
        self.ip = ip
        self.bufferSize = 10240

    def start(self):  # 启动监听，接收数据
    	# 定义一个socket对象，地址簇为ipv4，类型为流式socket
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            s.bind((self.ip, self.port))  # 绑定
            # 设置最大链接数量为10
            s.listen(10)  # 监听
            print('等待客户端连接')
            while True:  # 一直等待新的连接
                try:
                	'''
                	接受连接并返回（conn,address）
                	其中conn是新的套接字对象
                	可以用来接收和发送数据。
                	address是连接客户端的地址(turtle类型)。
                	'''
                    conn, addr = s.accept()
                    print('客户端连接 ' + addr[0] + ':' + str(addr[1]))
                    while True:  # 不知道客户端发送数据大小，循环接收
                    	'''
                    	接受套接字的数据
                    	数据以字符串形式返回(type == bytes)
                    	bufsize指定最多可以接收的数量
                    	flag提供有关消息的其他信息，通常可以忽略。
                    	'''
                        data = conn.recv(self.bufferSize)
                        if not data:
                            break
                        else:
                            self.executeCommand(conn,data)
                    conn.close()
                except socket.error as e:
                    print(e)
                    conn.close()  # 关闭连接
        finally:
            s.close()  # 关闭服务端

    def executeCommand(self, tcpCliSock, data):  # 解析并执行命令
        try:
        	# 因为是bytes类型所以要进行解码
            message = data.decode("utf-8")
            if os.path.isfile(message):#判断是否是文件
                filesize = str(os.path.getsize(message))#获取文件大小
                print("文件大小为：",filesize)
                tcpCliSock.send(filesize.encode())#发送文件大小
                data = tcpCliSock.recv(self.bufferSize)  
                print("开始发送")
                f = open(message, "rb")#打开文件
                for line in f:
                    tcpCliSock.send(line)#发送文件内容
            else:
            	'''
            	将string中的数据发送到连接的套接字。
            	返回值是要发送的字节数量

				PS:该数量可能小于string的字节大小。
            	'''
                tcpCliSock.send(('0001'+os.popen(message).read()).encode('utf-8'))
        except:
            raise



if __name__ == '__main__':
    s = server('', 8800)
    s.start()

客户端：(user.py)

# -*- coding: UTF-8 -*-

import socket
import sys
import re
import os

class Client:
    def __init__(self,serverIp,serverPort):
        self.serverIp=serverIp #待连接的远程主机的域名
        self.serverPort = serverPort
        self.bufferSize = 10240

    def connet(self): #连接方法
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        except socket.error as e:
            print("Failed to create socket. Error: %s"%e)
            
        try:
            s.connect((self.serverIp,self.serverPort))
            while True:
                message = input('> ')#接收用户输入
                if not message:
                    break
                s.send(bytes(message, 'utf-8'))#发送命令
                data = s.recv(self.bufferSize)#接收数据
                if not data:
                    break
                if re.search("^0001",data.decode('utf-8','ignore')):#判断数据类型
                    print(data.decode('utf-8')[4:])
                else:#文件内容处理
                    s.send("File size received".encode())#通知服务端可以发送文件了
                    file_total_size = int(data.decode())#总大小
                    received_size = 0
                    f = open("new" +os.path.split(message)[-1], "wb")#创建文件
                    while received_size < file_total_size:
                        data = s.recv(self.bufferSize)
                        f.write(data)#写文件
                        received_size += len(data)#累加接收长度
                        print("已接收:", received_size)
                    f.close()#关闭文件
                    print("receive done", file_total_size, " ", received_size)
        except socket.error:
            s.close()
            raise #退出进程
        finally:
            s.close()


if __name__ == '__main__':
    cl = Client('127.0.0.1',8800)
    cl.connet()
    sys.exit() #退出进程

非阻塞式服务器

多客户端同时连接服务端的场景下，处理起来要复杂得多，通常的解决方案是利用多线程或者多进程来解决并发问题，但是编程难度成倍提升。

在Python中我们还有一个折中的选择就是selectors模块，该模块基于Unix经典的select系统调用模型，它可以监听I/O操作的结果以实现异步调用，基于此种方案可以同时挂起多个socket连接，根据读写状态进行回调。

内部原理我们在本系列文章中不做过多解释，同学们掌握基本用法即可。模块参考：https://docs.python.org/3/library/selectors.html
同时在数据收发上，可能会出现“粘包”的情况，需要自定义数据封包协议来解决这样的问题.
粘包的概念
下面我们开始基于selectors构建服务端和客户端。
服务器（server.py）

# -*- coding: UTF-8 -*-

import socket
import sys
import selectors
import types

class server:
    def __init__(self,ip,port):
        self.port=port
        self.ip=ip
        self.selector  = selectors.DefaultSelector()#初始化selector

    def start(self):
        s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        try:
            s.bind((self.ip,self.port))
            # 默认无连接数限制
            s.listen()
            print('等待连接：',(self.ip,self.port))
            # 这一步很关键，调用之后，socket调用将不再阻塞当前程序。
            s.setblocking(False)
            self.selector.register(s,selectors.EVENT_READ,None)#注册I/O对象
            while True:
                events = self.selector.select(timeout=None)#阻塞调用，等待新的读/写事件
                for key, mask in events:
                    if key.data is None:#新的连接请求
                        self.accept_wrapper(key.fileobj)
                    else:#收到客户端连接发送的数据
                        self.service_connection(key, mask)
        except socket.error as e:
            print(e)
            sys.exit()
        finally:
             s.close() #关闭服务端

    def accept_wrapper(self,sock):
        conn, addr = sock.accept()  # Should be ready to read
        print('接收客户端连接', addr)
        conn.setblocking(False) #非阻塞
        '''
        调用types.SimpleNamespace来创建一个动态对象，保存我们需要的信息
        这里定义了addr（ip地址）、inb（传入数据）、outb（传出数据）三个字段
        接下来注册的事件选择读和写，可以在循环中获取连接的可读、可写状态
        '''
        data = types.SimpleNamespace(addr=addr, inb=b'', outb=b'')#socket数据
        events = selectors.EVENT_READ | selectors.EVENT_WRITE #监听读写
        self.selector.register(conn, events, data=data)#注册客户端socket

    def service_connection(self,key, mask):
        sock = key.fileobj
        data = key.data
        if mask & selectors.EVENT_READ:
            recv_data = sock.recv(1024)  # 接收数据
            if recv_data:
                data.outb += recv_data
            else:#客户端断开连接
                print('关闭连接', data.addr)
                self.selector.unregister(sock)#取消注册，防止出错
                sock.close()
        if mask & selectors.EVENT_WRITE:
            if data.outb:
                print('发送', repr(data.outb), '到', data.addr)
                sent = sock.send(data.outb)  
                data.outb = data.outb[sent:]


if __name__ == '__main__':
    s = server('',8800)
    s.start()

客户端(user.py)

# -*- coding: UTF-8 -*-

import socket
import sys
import selectors
import types

# 测试类


class Client:
    def __init__(self, host, port, numConn):
        self.host = host  # 待连接的远程主机的域名
        self.port = port
        self.message = [b'message 1 from client', b'message 2 from client']
        self.numConn = numConn
        self.selector = selectors.DefaultSelector()

    def connet(self):  # 连接方法
        server_addr = (self.host, self.port)
        for i in range(0, self.numConn):
            connid = i + 1
            print('开始连接', connid, '到', server_addr)
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.setblocking(False)
            '''
            由于connect()方法会立即触发一个 BlockingIOError异常
            所以我们使用connect_ex()方法取代它
            connect_ex()会返回一个错误指示 errno.EINPROGRESS
            不像connect()方法直接在进程中返回异常
            一旦连接成功socket就可以进行读写并且通过select()方法返回。
            '''
            sock.connect_ex(server_addr)
            
            events = selectors.EVENT_READ | selectors.EVENT_WRITE
            data = types.SimpleNamespace(connid=connid,
                                     msg_total=sum(len(m) for m in self.message),
                                     recv_total=0,
                                     messages=list(self.message),
                                     outb=b'')
            self.selector.register(sock, events, data=data)

        try:
            while True:
                events = self.selector.select(timeout=1)
                if events:
                    for key, mask in events:
                        self.service_connection(key, mask)

        finally:
            self.selector.close()
        
    def service_connection(self,key, mask):
        sock = key.fileobj
        data = key.data
        if mask & selectors.EVENT_READ:
            recv_data = sock.recv(1024)  
            if recv_data:
                print("收到", repr(recv_data), "来自连接", data.connid)
                data.recv_total += len(recv_data)
            if not recv_data or data.recv_total == data.msg_total:
                print("关闭连接：", data.connid)
                self.selector.unregister(sock)
                sock.close()
        if mask & selectors.EVENT_WRITE:
            if not data.outb and data.messages:
                data.outb = data.messages.pop(0)
            if data.outb:
                print("发送", repr(data.outb), "到连接", data.connid)
                sent = sock.send(data.outb)  #发送数据
                data.outb = data.outb[sent:]#清空数据



if __name__ == '__main__':
    cl = Client('127.0.0.1', 8800, 5)
    cl.connet()

总结

当使用 TCP 连接时，会从一个连续的字节流读取的数据，好比从磁盘上读取数据，不同的是你是从网络读取字节流。然而，和使用 f.seek() 读文件不同，没法定位 socket 的数据流的位置，如果可以像文件一样定位数据流的位置（使用下标），那你就可以随意的读取你想要的数据。当字节流入你的 socket 时，会需要有不同的网络缓冲区，如果想读取他们就必须先保存到其它地方，使用 recv() 方法持续的从 socket 上读取可用的字节流相当于从 socket 中读取的是一块一块的数据，你必须使用 recv() 方法不断的从缓冲区中读取数据，直到你的应用确定读取到了足够的数据。

什么时候算“足够”这取决于你的定义，就 TCP socket 而言，它只通过网络发送或接收原始字节，它并不了解这些原始字节的含义。

这可以让我们定义一个应用层协议，来解决这个问题，类似于HTTP协议。简单来说，你的应用会发送或者接收消息，这些消息其实就是你的应用程序的协议。这些消息的长度、格式可以定义应用程序的语义和行为，这和我们之前说的从socket 中读取字节部分内容相关，当你使用 recv() 来读取字节的时候，你需要知道读的字节数，并且决定什么时候算读取完成。这些都是怎么完成的呢？在每条消息前面追加一个头信息，头信息中包括消息的长度和其它我们需要的字段。这样做的话我们只需要追踪头信息，当我们读到头信息时，就可以查到消息的长度并且读出所有字节。

让我们来定义一个完整的协议头：

可变长度的文本
基于 UTF-8 编码的 Unicode 字符集
使用 JSON 序列化的一个 Python 字典
其中必须具有的头应该有以下几个：

Name	Description
byteorder	机器的自觉序列，应用程序可能用不上
content-length	内容的字节长度
content-type	内容的类型
content-encoding	内容的编码类型

注意事项：

1.s.bind收发的是一个元组类型，而不是两个参数
2.在服务端创建新文件时要使用open(message, “rb”)的形式
3.另外数据传输还涉及大小端的问题，不同的CPU架构处理网络传输数据的字节顺序是不一样的
维基百科字节顺序
百度百科字节顺序