Python SocketServer 模块

内容学习记录自 :

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对象,<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()