内容学习记录自 :
https://docs.python.org/2/library/socketserver.html#asynchronous-mixins
在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对象,<socket._socketobject object at 0x1048be830>
print self.client_address # 客户端的地址和IP,('127.0.0.1', 55270)
print self.server # 服务端socketserver对象,<SocketServer.ThreadingTCPServer instance at 0x1048eeab8>
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()
