内容学习记录自 :
https://docs.python.org/2/library/socketserver.html#asynchronous-mixins
http://acen-chen.iteye.com/blog/290177
在SocketServer
模块中有四个基础的类,比较常用的是TCPServer
- TCPServer(server_address, RequestHandlerClass, bind_and_activate=True)
- UDPServer(server_address, RequestHandlerClass, bind_and_activate=True)
- UnixStreamServer(server_address, RequestHandlerClass, bind_and_activate=True)
- UnixDatagramServer(server_address, RequestHandlerClass, bind_and_activate=True)
这四个类的进程是同步的,即一次只能连接一个客户机并处理她的请求,请求结束后再接受其他请求。 解决办法是创建新的进程或者线程来处理每个请求。ForkingMixIn
和TheadingMixIn
两个混合类可以用来支持这种异步的行为。 实际上,SocketServer
模块提供了一些对些有用的类来解决你这个问题,它们是:ForkingUDPServer
、ForkingTCPServer
、ThreadingUDPServer
、ThreadingTCPServer
、ThreadingUnixStreamServer
和ThreadingUnixDatagramServer
。
fork
是通过复制进程来实现多进程,threading
是通过创建进程来实现同时处理多个请求。
如果要写一个自己的监听服务,我们要自己写一个请求处理的类来完成对请求数据的处理,SocketServer
中的BaseRequestHandler
是所有请求处理的类的父类。
例:写一个多线程服务,客户端发过来的数据,稍微处理再发送回去。
# server 服务端
import SocketServer
class MyTCPHandler(SocketServer.BaseRequestHandler):
def handle(self):
print self.request #客户端的socket对象,
print self.client_address # 客户端的地址和IP,('127.0.0.1', 55270)
print self.server # 服务端socketserver对象,
print "get connection from : " ,self.client_address
# 连接后,向客户端返回数据
self.request.send('hello')
flag = True
while flag:
# 接收客户端发来的数据
self.data = self.request.recv(4096).strip()
print self.data
if self.data == 'exit':
flag = False
final_data = "input is %s \r\n" % self.data
# 处理后返回数据
self.request.sendall(final_data)
h, p = '127.0.0.1', 9999
server = SocketServer.ThreadingTCPServer((h, p), MyTCPHandler)
server.serve_forever()
# client 客户端
import socket
client = socket.socket()
# 建立连接
ip_port = ('127.0.0.1', 9999)
client.connect(ip_port)
while True:
# 接受服务端发过来的数据
data = client.recv(1024)
print data
# 向服务端发送数据
inp = raw_input('client: ')
client.send(inp)
if inp == 'exit':
break
在程序中,自定义了一个MyTCPHandler
类来处理接受的数据,它的父类是BaseRequestHandler
,当一个新的连接来到时,server
会创建一个新的MyTCPHandler
实例并调用hande()
方法来处理该请求。server
继承自SocketServer.ThreadingTCPServer
,对于每个新的请求都会启动一个单独的线程来处理这个请求。如果用server.handle_request()
替代server.serve_forever()
,它将一个一个的处理连接请求,server.serve_forever()
只是反复的调用server.handle_request()
一般来说,你只需使用socket
服务之一,但是如果你需要创建你自己的子类的话,你可以覆盖我们下面提到的方法来定制它。
当服务被第一次创建的时候,__init__
函数调用server_bind()
方法来绑定监听socket(self.socket)
到正确的地址(self.server_address
)。然后调用server_activate()
来激活这个服务(默认情况下,调用socket
的listen
方法)。
这个socket
服务不做任何事情直到调用了handle_request
或serve_forever
方法。handle_request
调用get_request()
去等待和接收一个新的socket
连接,然后调用verify_request(request,client_address)
去看服务是否会处理这个连接(你可以在访问控制中使用这个,默认情况下面verify_request
总是返回true
)。如果会处理这个请求,handle_request
然后调用process_request(request,client_address)
,如果process_request(request,client_address)
导致一个异常的话,将调用handle_error(request,client_address)
。默认情况下,process_request
简单地调用finish_request(request,client_address)
;子进程和线程类覆盖了这个行为去开始一新的进程或线程,然后调用finish_request
。finish_request
实例化一个新的请求处理器,请求处理器轮流调用它们的handle()
方法。
当SocketServer
创建一个新的请求处理器时,它传递给这个处理器的__init__
函数的self
变量,以便于这个处理器能够访问关于这个服务的信息。
SocketServer
的fileno()
方法返回监听socket
的文件描述符。address_family
成员变量指定了监听socket
的socket
族(如AF_INET
),server_address
包含了监听socket
被绑定到的地址。socket
变量包含监听socket
自身。
请求处理器中:
即我们自己写的MyTCPHandler
类,请求处理器有setup()
、handle()
和finish()
方法,你可以覆盖它们来定制你自己的行为。一般情况下,你只需要覆盖handle()
方法。BaseRequestHandler
的__init__
函数调用setup()
方法来做初始化的工作,handle()
服务于请求,finish()
用于执行清理工作,如果handle
或setup
导致一个异常,finish
不会被调用。记住,你的请求处理器会为每个请求创建一个新的实例。
SocketServer
模块也定义了BaseRequestHandler
的两个子类:StreamRequestHandler
和DatagramRequestHandler
。它们覆盖了setup
和finish
方法并创建了两个文件对象rfile
和wfile
,你可以用这两个文件对象来向客户端读写数据,从而代替使用socket
方法。如下例子:
#-*- coding:utf-8 -*-
from SocketServer import ThreadingTCPServer, StreamRequestHandler
import traceback
class MyStreamRequestHandlerr(StreamRequestHandler):
def handle(self):
while True:
try:
data = self.rfile.readline().strip()
if not data: break
print "receive from (%r):%r" % (self.client_address, data)
self.wfile.write(data.upper())
except:
traceback.print_exc()
break
if __name__ == "__main__":
host = "" #主机名,可以是ip,像localhost的主机名,或""
port = 9999 #端口
addr = (host, port)
#ThreadingTCPServer从ThreadingMixIn和TCPServer继承
#class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
server = ThreadingTCPServer(addr, MyStreamRequestHandlerr)
server.serve_forever()