socketserver的基本使用

socketserver的介绍：

• socketserver是标准库中的一个高级模块
• socketserver可以简化创建客户端跟创建服务端的代码
• SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。

socketserver的使用：

• 首先导入模块：import socketserver
• 初始化控制器类Handler【Handler是一个继承BaseRequestHandler的类Handler中的handle方法决定了每一个连接过来的操作】 【控制器类的类名可以是其他的，不一定是Handler，只要继承了BaseRequestHandler就行】
• • init():初始化控制设置，初始化连接套接字，地址，处理实例等信息
  • handle()： 定义了如何处理每一个连接。
  • setup()： 在handle()之前执行.一般用作设置默认之外的连接配置
  • finish()：在handle()之后执行。
  • 变量：
  • • self.request属性是套接字对象,所以使用self.request.xxxx调用套接字的函数
    • self.server包含调用处理程序的实例
    • self.client_address是客户端地址信息
• 定义服务端类型【将Handler类和服务端的地址端口参数传入】：
• • TCPServer 支持ipv4的TCP协议的服务器。
    • server=socketserver.TCPServer((HOST,PORT),Handler)【Handler】
  • UDPServer 支持ipv4的UDP协议的服务器。
    • server=socketserver.UDPServer((HOST,PORT),Handler)
• 运行服务端
• • 持续循环运行：serve_forever()，即使一个连接报错了，但不会导致程序停止，而是会持续运行，与其他客户端通信
    • server.serve_forever()
    • 
  • 停止server_forever：shutdown()
    • server.shutdown()

服务端：

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        try:
            while True:
                self.data=self.request.recv(1024)
                print("{} send:".format(self.client_address),self.data)
                if not self.data:
                    print("connection lost")
                    break
                self.request.sendall(self.data.upper())
        except Exception as e:
            print(self.client_address,"连接断开")
        finally:
            self.request.close()
    def setup(self):
        print("before handle,连接建立：",self.client_address)
    def finish(self):
        print("finish run  after handle")

if __name__=="__main__":
    HOST,PORT = "localhost",9999
    server=socketserver.TCPServer((HOST,PORT),MyTCPHandler)

    server.serve_forever()

客户端：

import socket

client=socket.socket()

client.connect(('localhost',9999))
while True:
    cmd=input("(quit退出)>>").strip()
    if len(cmd)==0:
        continue
    if cmd=="quit":
        break
    client.send(cmd.encode())
    cmd_res=client.recv(1024)
    print(cmd_res.decode())

client.close()

socketserver的异步服务端：

• 多线程：ThreadingTCPServer，ThreadingTCPServer实现的Soket服务器内部会为每个client创建一个 “线程”，该线程用来和客户端进行交互。
• 多进程：ForkingTCPServer（Unix），ForkingTCPServer和ThreadingTCPServer的使用和执行流程基本一致，只不过在内部分别为请求者建立 “线程”  和 “进程”。

1、ThreadingTCPServer

1.1、ThreadingTCPServer基础

使用ThreadingTCPServer:

• 创建一个继承自 SocketServer.BaseRequestHandler 的类
• 类中必须定义一个名称为 handle 的方法
• 启动ThreadingTCPServer

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        try:
            while True:
                self.data=self.request.recv(1024)
                print("{} send:".format(self.client_address),self.data)
                if not self.data:
                    print("connection lost")
                    break
                self.request.sendall(self.data.upper())
        except Exception as e:
            print(self.client_address,"连接断开")
        finally:
            self.request.close()
    def setup(self):
        print("before handle,连接建立：",self.client_address)
    def finish(self):
        print("finish run  after handle")


HOST,PORT = "localhost",9999

server=socketserver.ThreadingTCPServer((HOST,PORT),MyTCPHandler)#多线程版
server.serve_forever()

1.2、ThreadingTCPServer源码剖析

ThreadingTCPServer的类图关系如下：

内部调用流程为：

• 启动服务端程序
• 执行 TCPServer.__init__ 方法，创建服务端Socket对象并绑定 IP 和 端口
• 执行 BaseServer.__init__ 方法，将自定义的继承自SocketServer.BaseRequestHandler 的类 MyTCPHandler赋值给self.RequestHandlerClass
• 执行 BaseServer.server_forever 方法，While 循环一直监听是否有客户端请求到达 ...
• 当客户端连接到达服务器
• 执行 ThreadingMixIn.process_request 方法，创建一个 “线程” 用来处理请求
• 执行 ThreadingMixIn.process_request_thread 方法
• 执行 BaseServer.finish_request 方法，执行 self.RequestHandlerClass()  即：执行 自定义 MyTCPHandler的构造方法（自动调用基类BaseRequestHandler的构造方法，在该构造方法中又会调用 MyTCPHandler的handle方法）

ThreadingTCPServer相关源码：

class BaseServer:

    def __init__(self, server_address, RequestHandlerClass):
        """Constructor.  May be extended, do not override."""
        self.server_address = server_address
        self.RequestHandlerClass = RequestHandlerClass
        self.__is_shut_down = threading.Event()
        self.__shutdown_request = False

    #poll_interval表示select轮询的时间
    # serve_forever函数，创建server对象之后我们会使用server对象开启无限循环，
    # 接受一个参数poll_interval，用于表示select轮询的时间，
    # 然后进入一个死循环，用select方法进行网络IO的监听，
    # 这里通过调用selector.register(self, selectors.EVENT_READ)进行了注册，
    # 当ready有返回是，表示有IO连接或者数据，这个时候会调用_handle_request_noblock
    def serve_forever(self, poll_interval=0.5):
        self.__is_shut_down.clear()
        try:
            # XXX: Consider using another file descriptor or connecting to the
            # socket to wake this up instead of polling. Polling reduces our
            # responsiveness to a shutdown request and wastes cpu at all other
            # times.
            with _ServerSelector() as selector:
                selector.register(self, selectors.EVENT_READ)#检测是否注册

                while not self.__shutdown_request:
                    ready = selector.select(poll_interval)  #进行网络IO的监听
                    if ready:
                        self._handle_request_noblock()#开始处理一个请求，并且是非阻塞

                    self.service_actions()
        finally:
            self.__shutdown_request = False
            self.__is_shut_down.set()

    def finish_request(self, request, client_address):
        """Finish one request by instantiating RequestHandlerClass."""
        self.RequestHandlerClass(request, client_address, self)

class ThreadingMixIn:
    """Mix-in class to handle each request in a new thread."""

    # Decides how threads will act upon termination of the
    # main process
    daemon_threads = False

    def process_request_thread(self, request, client_address):
        """Same as in BaseServer but as a thread.

        In addition, exception handling is done here.

        """
        try:
            self.finish_request(request, client_address)
        except Exception:
            self.handle_error(request, client_address)
        finally:
            self.shutdown_request(request)

    #MixIn子类通过重写该方法，进行多线程或多进程的配置
    def process_request(self, request, client_address):
        """Start a new thread to process the request."""
        t = threading.Thread(target = self.process_request_thread,
                             args = (request, client_address))
        t.daemon = self.daemon_threads
        t.start()

 

SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 Threading 两个东西，其实本质上就是在服务器端为每一个客户端创建一个线程，当前线程用来处理对应客户端的请求，所以，可以支持同时n个客户端链接（长连接）。

2、ForkingTCPServer

ForkingTCPServer和ThreadingTCPServer的使用和执行流程基本一致，只不过在内部分别为请求者建立 “线程”  和 “进程”。

基本使用：

import SocketServer

class MyServer(SocketServer.BaseRequestHandler):

    def handle(self):
        pass

if __name__ == '__main__':
    server = SocketServer.ForkingTCPServer(('127.0.0.1',8009),MyServer)
    server.serve_forever()