Python网络编程篇之socketserver
1.socketserver模块和类
socketserver是标准库中的一个高级模块,目标是简化很多样板代码(创建网络客户端和服务器所必须的代码)
这个模块封装了socket编程所需要的各种各样的类,现在可以使用类来编写应用程序。
因为以面向对象的方式处理事务有助于组织数据,以及逻辑性地将功能放在正确的地方,应用程序现在是时间驱动的,这意味着只有在系统中的时间发生时,它才会工作。
SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ,从而实现并发处理多个客户端请求的Socket服务端。即:每个客户端请求连接到服务器时,Socket服务端都会在服务器是创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求。
socketserver模块可以简化网络服务器的编写,Python把网络服务抽象成两个主要的类
一个是Server类,用于处理连接相关的网络操作
另外一个则是RequestHandler类,用于处理数据相关的操作。并且提供两个MixIn 类,用于扩展 Server,实现多进程或多线程。
类的描述
1.BaseServer 包含核心服务器功能和 mix-in类的钩子;仅用于推导,这样不会创建这个类的实例;可以用TCPServer 或 UDPServer 创建类的实例
2.TCPServer/UDPServer 基础的网络同步TCP/UDP服务器
3.UnixStreamServer/UnixDatagramServer 基于文件的基础同步TCp/UDP服务器
4.ForkingMixIn/ThreadingMixIn 核心派出或线程功能;只用做mix-in类与一个服务器类配合实现一些异步性;不能直接实例化这个类
5.ThreadingTCPServer/ThreadingUDPServer ThreadingMixIn 和 TCPServer/UDPServer的组合
6.ForkingTCPServer/ForkingUDPServer ForkingMixIn 和 TCPServer/UDPServer的组合
7.BaseRequestHandler 包含处理服务器请求的核心功能;仅仅用于推导,这样无法创建这个类的实例;可以用StreamRequestHandler 或 DatagramRequestHandler 创建类的实例
8.StreamRequestHandler/DatagramRequestHandler 实现Tcp/UDP服务器的服务处理器
四个基础类的继承关系
+------------+ | BaseServer | +------------+ | v +-----------+ +------------------+ | TCPServer |------->| UnixStreamServer | +-----------+ +------------------+ | v +-----------+ +--------------------+ | UDPServer |------->| UnixDatagramServer | +-----------+ +--------------------+
这四个类使用”同步”来处理请求。只有处理完所有请求后,才可以开始处理新的请求!不适合使用在处理单个请求需要花费大量时间的场合。因为需要花费大量的计算时间,或者这因为它会返回大量的数据导致客户端处理速度变得很慢。解决方法是创建单独的进程或者线程处理每一个请求。在类内部的ForkingMixIn和ThreadingMixIn 组合可以支持”异步”的操作。
所以,让你的socketserver并发起来, 必须选择使用以下一个多并发的类
class socketserver.
ForkingTCPServer
class socketserver.
ForkingUDPServer
class socketserver.
ThreadingTCPServer
class socketserver.
ThreadingUDPServer
2.ThreadingTCPServer
ThreadingTCPServer实现的Soket服务器内部会为每个client创建一个 “线程”,该线程用来和客户端进行交互。
首先,必须通过继承BaseRequestHandler类并重写handle()方法来创建请求处理程序类; 这个方法将处理传入的请求。
其次,必须实例化其中一个服务器类,并将其传递给服务器的地址和请求处理程序类。
然后,调用服务器对象的handle_request()or serve_forever()方法来处理一个或多个请求。
最后,调用server_close()关闭套接字。
ThreadingTCPServer---->TCPServer ------>BaseServer------>RequestHandlerClass | (__init__) server_forever | finish_request |-----> ThreadingMixIn.process_request() |----->ThreadingMixIn.process_request_thread()
内部调用流程为:
- 启动服务端程序
- 执行 TCPServer.__init__ 方法,创建服务端Socket对象并绑定 IP 和 端口
- 执行 BaseServer.__init__ 方法,将自定义的继承自SocketServer.BaseRequestHandler 的类 MyRequestHandle赋值给self.RequestHandlerClass
- 执行 BaseServer.server_forever 方法,While 循环一直监听是否有客户端请求到达 …
- 当客户端连接到达服务器
- 执行 ThreadingMixIn.process_request 方法,创建一个 “线程” 用来处理请求
- 执行 ThreadingMixIn.process_request_thread 方法
- 执行 BaseServer.finish_request 方法,执行 self.RequestHandlerClass() 即:执行 自定义 MyRequestHandler 的构造方法(自动调用基类BaseRequestHandler的构造方法,在该构造方法中又会调用 MyRequestHandler的handle方法)
服务端
# -*- coding: utf-8 -*- # 2017/11/25 20:15 import socketserver class MyServer(socketserver .BaseRequestHandler): def handle(self): # print self.request,self.client_address,self.server conn = self.request conn.sendall(bytes('欢迎致电 10086,0转人工服务.',encoding='utf8')) Flag = True while Flag: data = conn.recv(1024) data = str(data, encoding='utf8') if data == 'exit': Flag = False elif data == '0': conn.sendall(bytes('通过可能会被录音',encoding='utf8')) else: conn.sendall(bytes('请重新输入.',encoding='utf8')) if __name__ == '__main__': server = socketserver .ThreadingTCPServer(('127.0.0.1',8009),MyServer) server.serve_forever()
服务端源码模拟
1 # -*- coding: utf-8 -*- 2 # 2017/11/25 20:37 3 import socket 4 import threading 5 import select 6 7 8 def process(request, client_address): 9 print(request,client_address) 10 conn = request 11 conn.sendall(bytes('欢迎致电 10086,请输入1xxx,0转人工服务.', encoding='utf8')) 12 Flag = True 13 while Flag: 14 data = conn.recv(1024) 15 data = str(data, encoding='utf8') 16 if data == 'exit': 17 Flag = False 18 elif data == '0': 19 print(data) 20 conn.sendall(bytes('通过可能会被录音.balabala一大推', encoding='utf8')) 21 else: 22 conn.sendall(bytes('请重新输入.', encoding='utf8')) 23 24 sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 25 sk.bind(('127.0.0.1',8002)) 26 sk.listen(5) 27 28 while True: 29 r, w, e = select.select([sk,],[],[],1) 30 print('looping') 31 if sk in r: 32 print('get request') 33 request, client_address = sk.accept() 34 t = threading.Thread(target=process, args=(request, client_address)) 35 t.daemon = False 36 t.start() 37 sk.close()
View Code
如精简代码可以看出,SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 Threading 两个东西,其实本质上就是在服务器端为每一个客户端创建一个线程,当前线程用来处理对应客户端的请求,所以,可以支持同时n个客户端链接(长连接)。
客户端
# -*- coding: utf-8 -*- # 2017/11/25 20:16 import socket ip_port = ('127.0.0.1',8009) sk = socket.socket() sk.connect(ip_port) sk.settimeout(5) while True: data = sk.recv(1024) data = str(data, encoding='utf8') print('receive:',data) inp = input('please input:') sk.sendall(bytes(inp,encoding="utf8")) if inp == 'exit': break sk.close()
ForkingTCPServer只是将 ThreadingTCPServer 实例中的代码:
SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 os.fork 两个东西,其实本质上就是在服务器端为每一个客户端创建一个进程,当前新创建的进程用来处理对应客户端的请求,所以,可以支持同时n个客户端链接(长连接)。
server
=
SocketServer.ThreadingTCPServer((
'127.0.0.1'
,
8009
),MyRequestHandler)
变更为:
server
=
SocketServer.ForkingTCPServer((
'127.0.0.1'
,
8009
),MyRequestHandler)
3.class socketserver.
BaseServer
(server_address, RequestHandlerClass) 主要有以下方法
类socketserver.BaseServer(server_address,RequestHandlerClass)
这是模块中所有服务器对象的超类。它定义了下面给出的接口,但不实现大多数在子类中完成的方法。这两个参数存储在相应的server_address和RequestHandlerClass属性中。
fileno()
返回服务器正在侦听的套接字的整数文件描述符。这个函数通常被传递给选择器,允许在同一个进程中监视多个服务器。
handle_request()
处理一个请求。该函数按顺序调用以下方法:get_request(),verify_request()和process_request()。如果处理程序类的用户提供的handle()方法引发异常,则将调用服务器的handle_error()方法。如果在超时秒内没有收到请求,则会调用handle_timeout(),并返回handle_request()。
serve_forever(POLL_INTERVAL = 0.5)
处理请求直到显式关闭()请求。轮询关闭每个poll_interval秒。忽略超时属性。它还调用service_actions(),子类或mixin可以使用它来提供特定于给定服务的操作。例如,ForkingMixIn类使用service_actions()来清理僵尸子进程。
在版本3.3中进行了更改:将service_actions调用添加到了serve_forever方法。
service_actions()
这在serve_forever()循环中被调用。这个方法可以被子类或mixin类覆盖,以执行特定于给定服务的操作,例如清理操作。
3.3版本中的新功能
shutdown()
告诉serve_forever()循环停止并等待,直到它结束。
server_close()
清理服务器。可能会被覆盖。
address_family
服务器套接字所属的协议族。通常的例子是socket.AF_INET和socket.AF_UNIX。
RequestHandlerClass
用户提供的请求处理程序类;这个类的一个实例是为每个请求创建的。
server_address
服务器正在侦听的地址。地址格式因协议族而异,有关详细信息,请参阅套接字模块的文档。对于Internet协议,这是一个包含给出地址的字符串的元组,以及一个整数端口号:(’127.0.0.1’,80)。
socket
服务器将侦听传入请求的套接字对象。
服务器类支持以下类变量:
allow_reuse_address
服务器是否允许重用地址。这默认为False,可以在子类中设置来更改策略。
request_queue_size
请求队列的大小。如果处理单个请求需要很长时间,则在服务器繁忙时到达的所有请求都会被放入一个队列中,最多为request_queue_size请求。一旦队列已满,来自客户端的进一步请求将会得到“连接被拒绝”错误。默认值通常是5,但这可以由子类覆盖。
socket_type
服务器使用的套接字的类型; socket.SOCK_STREAM和socket.SOCK_DGRAM是两个常见的值。
timeout
超时持续时间(以秒为单位);如果不需要超时,则超时。如果handle_request()在超时期限内没有收到传入的请求,则调用handle_timeout()方法。
有许多服务器方法可以被TCPServer等基本服务器类的子类覆盖;这些方法对服务器对象的外部用户没有用处。
finish_request()
实际上通过实例化RequestHandlerClass并调用其handle()方法来处理请求。
get_request()
必须接受来自套接字的请求,并返回包含要用于与客户端通信的新套接字对象的2元组以及客户端的地址。
handle_error(request,client_address)
如果RequestHandlerClass实例的handle()方法引发异常,则调用此函数。默认操作是将回溯打印到标准输出,并继续处理更多的请求。
handle_timeout()
当timeout属性被设置为None以外的值时,该函数被调用,超时时间已经过去,没有收到请求。派生服务器的默认动作是收集退出的任何子进程的状态,而在线程服务器中,这个方法什么也不做。
process_request(request,client_address)
调用finish_request()来创建RequestHandlerClass的一个实例。如果需要,这个函数可以创建一个新的进程或线程来处理请求; ForkingMixIn和ThreadingMixIn类都是这样做的。
server_activate()
由服务器的构造函数调用以激活服务器。 TCP服务器的默认行为只是在服务器套接字上调用listen()。可能会被覆盖。
server_bind()
由服务器的构造函数调用,将套接字绑定到所需的地址。可能会被覆盖。
verify_request(request,client_address)
必须返回一个布尔值;如果值为True,