Python基础篇【第8篇】: Socket编程（二）SocketServer

SocketServer

在上一篇文章中我们学习了利用socket模块创建socket通信服务，但细心学习后就会发现利用socket模块创建的服务无法进行多进程的处理，当需要进行大量请求处理时，请求就会阻塞在队列中，甚至发生请求丢弃。并且如果我们需要大量的socket时，就需要重复创建许多socket、绑定端口..... ，对于程序员来说意味着重复书写大量无意义代码。

那有没有一种方式既能简化书写流程又能实现多线程开发呢 ? 答案是肯定的，这就是SocketServer模块。

SocketServer简化了网络服务器的编写。在进行socket创建时，使用SocketServer会大大减少创建的步骤，并且SocketServer使用了select它有4个类：TCPServer，UDPServer，UnixStreamServer，UnixDatagramServer。这4个类是同步进行处理的，另外通过ForkingMixIn和ThreadingMixIn类来支持异步。

使用SocketServer的步骤简介

1. 创建服务器的步骤。首先，你必须创建一个请求处理类，它是BaseRequestHandler的子类并重载其handle()方法。

2. 实例化一个服务器类，传入服务器的地址和请求处理程序类。

3. 最后，调用handle_request()(一般是调用其他事件循环或者使用select())或serve_forever()。

集成ThreadingMixIn类时需要处理异常关闭。daemon_threads指示服务器是否要等待线程终止，要是线程互相独立，必须要设置为True，默认是False。

无论用什么网络协议，服务器类有相同的外部方法和属性。

该模块在python3中已经更名为socketserver。

举例：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import SocketServer

class MyServer(SocketServer.BaseRequestHandler):
def handle(self):
　　　　　//some method....
if __name__='__main__':
 server = SocketServer.ThreadingTCPServer(('127.0.0.1,9999'),MyServer)
 server.serve_forever()

上面的步骤你可能会看不懂或者不理解为什么这么操作，下面我们进行详细解释。我们进行了如下的操作

一、自定义了一个MyServer类，继承自SocketServer模块中的BaseRequestHandler类。

二、在主函数中，使用SocketServer函数中的ThreadingTCPServer类进行了实例化操作。上边例子中实例化了对象为server，并在进行实例化时进行了参数的传递，参数一：服务器IP与端口号   参数二：自定义函数名称

源码分析

第二步中主函数操作。查看SocketServer模块源码[下面]可以发现。ThreadingTCPServer是继承自基类（ThreadingMixIn,TCPServer），但函数结构体是pass，也就是左右操作全部通过基类中方法进行执行，而基类中的TCPServer又有基类BaseServer。结构图如下

BaseServer　　　
 ↑
TCPServer        ThreadingMixIn
 ↑ ↑
     ThreadingTCPServer            

可以看出：ThreadingTCPServer的所有的方法都在它的基类函数中

各个基类作用分别是：

BaseServer：利用select创建多进程

TCPServer：创建每个进程的socket

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

第一步中的创建自定义类。继承自BaseRequestHandler类。从源码中看出他的作用就是接受请求，地址，和自定义名称，然后交给它的方法处理。默认的三个处理函数为pass，所以当我们使用时需要进行函数代码重构。

class BaseRequestHandler:

"""Base class for request handler classes.

 This class is instantiated for each request to be handled. The
 constructor sets the instance variables request, client_address
 and server, and then calls the handle() method. To implement a
 specific service, all you need to do is to derive a class which
 defines a handle() method.

 The handle() method can find the request as self.request, the
 client address as self.client_address, and the server (in case it
 needs access to per-server information) as self.server. Since a
 separate instance is created for each request, the handle() method
 can define arbitrary other instance variariables.

"""

def __init__(self, request, client_address, server):
 self.request = request
 self.client_address = client_address
 self.server = server
 self.setup()
try:
 self.handle()
finally:
 self.finish()

def setup(self):
pass

def handle(self):
pass

def finish(self):
pass

"""Generic socket server classes.
This module tries to capture the various aspects of defining a server:
For socket-based servers:
- address family:
 - AF_INET{,6}: IP (Internet Protocol) sockets (default)
 - AF_UNIX: Unix domain sockets
 - others, e.g. AF_DECNET are conceivable (see <socket.h>
- socket type:
 - SOCK_STREAM (reliable stream, e.g. TCP)
 - SOCK_DGRAM (datagrams, e.g. UDP)

For request-based servers (including socket-based):

- client address verification before further looking at the request
 (This is actually a hook for any processing that needs to look
 at the request before anything else, e.g. logging)
- how to handle multiple requests:
 - synchronous (one request is handled at a time)
 - forking (each request is handled by a new process)
 - threading (each request is handled by a new thread)

The classes in this module favor the server type that is simplest to
write: a synchronous TCP/IP server. This is bad class design, but
save some typing. (There's also the issue that a deep class hierarchy
slows down method lookups.)

There are five classes in an inheritance diagram, four of which represent
synchronous servers of four types:

 +------------+
 | BaseServer |
 +------------+
 |
 v
 +-----------+ +------------------+
 | TCPServer |------->| UnixStreamServer |
 +-----------+ +------------------+
 |
 v
 +-----------+ +--------------------+
 | UDPServer |------->| UnixDatagramServer |
 +-----------+ +--------------------+

Note that UnixDatagramServer derives from UDPServer, not from
UnixStreamServer -- the only difference between an IP and a Unix
stream server is the address family, which is simply repeated in both
unix server classes.

Forking and threading versions of each type of server can be created
using the ForkingMixIn and ThreadingMixIn mix-in classes. For
instance, a threading UDP server class is created as follows:

 class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass

The Mix-in class must come first, since it overrides a method defined
in UDPServer! Setting the various member variables also changes
the behavior of the underlying server mechanism.

To implement a service, you must derive a class from
BaseRequestHandler and redefine its handle() method. You can then run
various versions of the service by combining one of the server classes
with your request handler class.

The request handler class must be different for datagram or stream
services. This can be hidden by using the request handler
subclasses StreamRequestHandler or DatagramRequestHandler.

Of course, you still have to use your head!

For instance, it makes no sense to use a forking server if the service
contains state in memory that can be modified by requests (since the
modifications in the child process would never reach the initial state
kept in the parent process and passed to each child). In this case,
you can use a threading server, but you will probably have to use
locks to avoid two requests that come in nearly simultaneous to apply
conflicting changes to the server state.

On the other hand, if you are building e.g. an HTTP server, where all
data is stored externally (e.g. in the file system), a synchronous
class will essentially render the service "deaf" while one request is
being handled -- which may be for a very long time if a client is slow
to read all the data it has requested. Here a threading or forking
server is appropriate.

In some cases, it may be appropriate to process part of a request
synchronously, but to finish processing in a forked child depending on
the request data. This can be implemented by using a synchronous
server and doing an explicit fork in the request handler class
handle() method.

Another approach to handling multiple simultaneous requests in an
environment that supports neither threads nor fork (or where these are
too expensive or inappropriate for the service) is to maintain an
explicit table of partially finished requests and to use select() to
decide which request to work on next (or whether to handle a new
incoming request). This is particularly important for stream services
where each client can potentially be connected for a long time (if
threads or subprocesses cannot be used).

Future work:
- Standard classes for Sun RPC (which uses either UDP or TCP)
- Standard mix-in classes to implement various authentication
 and encryption schemes
- Standard framework for select-based multiplexing

XXX Open problems:
- What to do with out-of-band data?

BaseServer:
- split generic "request" functionality out into BaseServer class.
 Copyright (C) 2000 Luke Kenneth Casson Leighton <[e-mail]>

 example: read entries from a SQL database (requires overriding
 get_request() to return a table entry from the database).
 entry is processed by a RequestHandlerClass.

"""

# Author of the BaseServer patch: Luke Kenneth Casson Leighton

# XXX Warning!
# There is a test suite for this module, but it cannot be run by the
# standard regression test.
# To run it manually, run Lib/test/test_socketserver.py.

__version__ = "0.4"


import socket
import select
import sys
import os
import errno
try:
    import threading
except ImportError:
    import dummy_threading as threading

__all__ = ["TCPServer","UDPServer","ForkingUDPServer","ForkingTCPServer",
           "ThreadingUDPServer","ThreadingTCPServer","BaseRequestHandler",
           "StreamRequestHandler","DatagramRequestHandler",
           "ThreadingMixIn", "ForkingMixIn"]
if hasattr(socket, "AF_UNIX"):
    __all__.extend(["UnixStreamServer","UnixDatagramServer",
                    "ThreadingUnixStreamServer",
                    "ThreadingUnixDatagramServer"])

def _eintr_retry(func, *args):
    """restart a system call interrupted by EINTR"""
    while True:
        try:
            return func(*args)
        except (OSError, select.error) as e:
            if e.args[0] != errno.EINTR:
                raise

class BaseServer:

    """Base class for server classes.

 Methods for the caller:

 - __init__(server_address, RequestHandlerClass)
 - serve_forever(poll_interval=0.5)
 - shutdown()
 - handle_request() # if you do not use serve_forever()
 - fileno() -> int # for select()

 Methods that may be overridden:

 - server_bind()
 - server_activate()
 - get_request() -> request, client_address
 - handle_timeout()
 - verify_request(request, client_address)
 - server_close()
 - process_request(request, client_address)
 - shutdown_request(request)
 - close_request(request)
 - handle_error()

 Methods for derived classes:

 - finish_request(request, client_address)

 Class variables that may be overridden by derived classes or
 instances:

 - timeout
 - address_family
 - socket_type
 - allow_reuse_address

 Instance variables:

 - RequestHandlerClass
 - socket

    """

    timeout = None

    def __init__(self, server_address, RequestHandlerClass):　　　　　　实例参数最终传递到这里（ip与端口，自定义类）
        """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

    def server_activate(self):
        """Called by constructor to activate the server.

 May be overridden.

        """
        pass

    def serve_forever(self, poll_interval=0.5):
        """Handle one request at a time until shutdown.

 Polls for shutdown every poll_interval seconds. Ignores
 self.timeout. If you need to do periodic tasks, do them in
 another thread.
        """
        self.__is_shut_down.clear()
        try:
            while not self.__shutdown_request:
                # 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.
                r, w, e = _eintr_retry(select.select, [self], [], [],
 poll_interval)
                if self in r:
 self._handle_request_noblock()
        finally:
            self.__shutdown_request = False
            self.__is_shut_down.set()

    def shutdown(self):
        """Stops the serve_forever loop.

 Blocks until the loop has finished. This must be called while
 serve_forever() is running in another thread, or it will
 deadlock.
        """
        self.__shutdown_request = True
        self.__is_shut_down.wait()

    # The distinction between handling, getting, processing and
    # finishing a request is fairly arbitrary. Remember:
    #
    # - handle_request() is the top-level call. It calls
    # select, get_request(), verify_request() and process_request()
    # - get_request() is different for stream or datagram sockets
    # - process_request() is the place that may fork a new process
    # or create a new thread to finish the request
    # - finish_request() instantiates the request handler class;
    # this constructor will handle the request all by itself

    def handle_request(self):
        """Handle one request, possibly blocking.

 Respects self.timeout.
        """
        # Support people who used socket.settimeout() to escape
        # handle_request before self.timeout was available.
        timeout = self.socket.gettimeout()
        if timeout is None:
            timeout = self.timeout
        elif self.timeout is not None:
            timeout = min(timeout, self.timeout)
        fd_sets = _eintr_retry(select.select, [self], [], [], timeout)　　　　　　　　#调用select模块实现了多线程
        if not fd_sets[0]:
 self.handle_timeout()
            return
 self._handle_request_noblock()

    def _handle_request_noblock(self):
        """Handle one request, without blocking.

 I assume that select.select has returned that the socket is
 readable before this function was called, so there should be
 no risk of blocking in get_request().
        """
        try:
            request, client_address = self.get_request()
        except socket.error:
            return
        if self.verify_request(request, client_address):
            try:
 self.process_request(request, client_address)
            except:
 self.handle_error(request, client_address)
 self.shutdown_request(request)

    def handle_timeout(self):
        """Called if no new request arrives within self.timeout.

 Overridden by ForkingMixIn.
        """
        pass

    def verify_request(self, request, client_address):
        """Verify the request. May be overridden.

 Return True if we should proceed with this request.

        """
        return True

    def process_request(self, request, client_address):
        """Call finish_request.

 Overridden by ForkingMixIn and ThreadingMixIn.

        """
 self.finish_request(request, client_address)
 self.shutdown_request(request)

    def server_close(self):
        """Called to clean-up the server.

 May be overridden.

        """
        pass

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

    def shutdown_request(self, request):
        """Called to shutdown and close an individual request."""
 self.close_request(request)

    def close_request(self, request):
        """Called to clean up an individual request."""
        pass

    def handle_error(self, request, client_address):
        """Handle an error gracefully. May be overridden.

 The default is to print a traceback and continue.

        """
        print '-'*40
        print 'Exception happened during processing of request from',
        print client_address
        import traceback
        traceback.print_exc() # XXX But this goes to stderr!
        print '-'*40


class TCPServer(BaseServer):　　　ThreadingTCPServer基类之一，它又有自己的基类BaseServer　　　"""Base class for various socket-based server classes.

 Defaults to synchronous IP stream (i.e., TCP).

 Methods for the caller:

 - __init__(server_address, RequestHandlerClass, bind_and_activate=True)
 - serve_forever(poll_interval=0.5)
 - shutdown()
 - handle_request() # if you don't use serve_forever()
 - fileno() -> int # for select()

 Methods that may be overridden:

 - server_bind()
 - server_activate()
 - get_request() -> request, client_address
 - handle_timeout()
 - verify_request(request, client_address)
 - process_request(request, client_address)
 - shutdown_request(request)
 - close_request(request)
 - handle_error()

 Methods for derived classes:

 - finish_request(request, client_address)

 Class variables that may be overridden by derived classes or
 instances:

 - timeout
 - address_family
 - socket_type
 - request_queue_size (only for stream sockets)
 - allow_reuse_address

 Instance variables:

 - server_address
 - RequestHandlerClass
 - socket

    """

    address_family = socket.AF_INET

    socket_type = socket.SOCK_STREAM

    request_queue_size = 5

    allow_reuse_address = False

    def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
        """Constructor. May be extended, do not override."""
        BaseServer.__init__(self, server_address, RequestHandlerClass)　　　　　　　　调用它自己基类函数BaseServer的初始化函数进行多线程的启动
        self.socket = socket.socket(self.address_family,self.socket_type)　　　　　　创建启动的独立线程socket
        if bind_and_activate:
            try:
 self.server_bind()
 self.server_activate()
            except:
 self.server_close()
                raise

    def server_bind(self):
        """Called by constructor to bind the socket.

 May be overridden.

        """
        if self.allow_reuse_address:
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 self.socket.bind(self.server_address)　　　　　　　　　　　　　　　　　　　　绑定地址
        self.server_address = self.socket.getsockname()
def server_activate(self):
        """
　　　　 Called by constructor to activate the server. May be overridden.可以被重构
        """
 self.socket.listen(self.request_queue_size)　　　　　　　　　　　　　　　　 端口检听

 def server_close(self):
        """Called to clean-up the server.
 May be overridden.
        """
 self.socket.close()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　关闭socket

    def fileno(self):
        """Return socket file number.

 Interface required by select().

        """
        return self.socket.fileno()

    def get_request(self):
        """Get the request and client address from the socket.
 May be overridden.
        """
        return self.socket.accept()

    def shutdown_request(self, request):
        """Called to shutdown and close an individual request."""
        try:
            #explicitly shutdown. socket.close() merely releases
            #the socket and waits for GC to perform the actual close.
 request.shutdown(socket.SHUT_WR)
        except socket.error:
            pass #some platforms may raise ENOTCONN here
 self.close_request(request)

    def close_request(self, request):
        """Called to clean up an individual request."""
 request.close()


class UDPServer(TCPServer):

    """UDP server class."""

    allow_reuse_address = False

    socket_type = socket.SOCK_DGRAM

    max_packet_size = 8192

    def get_request(self):
        data, client_addr = self.socket.recvfrom(self.max_packet_size)
        return (data, self.socket), client_addr

    def server_activate(self):
        # No need to call listen() for UDP.
        pass

    def shutdown_request(self, request):
        # No need to shutdown anything.
 self.close_request(request)

    def close_request(self, request):
        # No need to close anything.
        pass

class ForkingMixIn:

    """Mix-in class to handle each request in a new process."""

    timeout = 300
    active_children = None
    max_children = 40

    def collect_children(self):
        """Internal routine to wait for children that have exited."""
        if self.active_children is None:
            return

        # If we're above the max number of children, wait and reap them until
        # we go back below threshold. Note that we use waitpid(-1) below to be
        # able to collect children in size(<defunct children>) syscalls instead
        # of size(<children>): the downside is that this might reap children
        # which we didn't spawn, which is why we only resort to this when we're
        # above max_children.
        while len(self.active_children) >= self.max_children:
            try:
                pid, _ = os.waitpid(-1, 0)
 self.active_children.discard(pid)
            except OSError as e:
                if e.errno == errno.ECHILD:
                    # we don't have any children, we're done
 self.active_children.clear()
                elif e.errno != errno.EINTR:
                    break

        # Now reap all defunct children.
        for pid in self.active_children.copy():
            try:
                pid, _ = os.waitpid(pid, os.WNOHANG)
                # if the child hasn't exited yet, pid will be 0 and ignored by
                # discard() below
 self.active_children.discard(pid)
            except OSError as e:
                if e.errno == errno.ECHILD:
                    # someone else reaped it
 self.active_children.discard(pid)

    def handle_timeout(self):
        """Wait for zombies after self.timeout seconds of inactivity.

 May be extended, do not override.
        """
 self.collect_children()

    def process_request(self, request, client_address):
        """Fork a new subprocess to process the request."""
 self.collect_children()
        pid = os.fork()
        if pid:
            # Parent process
            if self.active_children is None:
                self.active_children = set()
 self.active_children.add(pid)
            self.close_request(request) #close handle in parent process
            return
        else:
            # Child process.
            # This must never return, hence os._exit()!
            try:
 self.finish_request(request, client_address)
 self.shutdown_request(request)
 os._exit(0)
            except:
                try:
 self.handle_error(request, client_address)
 self.shutdown_request(request)
                finally:
                    os._exit(1)


class ThreadingMixIn:　　　　　　　　　　基类2
    """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)
 self.shutdown_request(request)
        except:
 self.handle_error(request, client_address)
 self.shutdown_request(request)

    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()


class ForkingUDPServer(ForkingMixIn, UDPServer): pass
class ForkingTCPServer(ForkingMixIn, TCPServer): pass

class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

if hasattr(socket, 'AF_UNIX'):

    class UnixStreamServer(TCPServer):
        address_family = socket.AF_UNIX

    class UnixDatagramServer(UDPServer):
        address_family = socket.AF_UNIX

    class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): pass

    class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): pass

class BaseRequestHandler:　　　　
自定义MyServer自继承这里，主要用于处理来自每个线程的请求，函数拥有三个方法，但是每个方法的结构体都没pass，所以我们在继承以后需要对方法进行重构。
    """Base class for request handler classes.

 This class is instantiated for each request to be handled. The
 constructor sets the instance variables request, client_address
 and server, and then calls the handle() method. To implement a
 specific service, all you need to do is to derive a class which
 defines a handle() method.

 The handle() method can find the request as self.request, the
 client address as self.client_address, and the server (in case it
 needs access to per-server information) as self.server. Since a
 separate instance is created for each request, the handle() method
 can define arbitrary other instance variariables.
    """

    def __init__(self, request, client_address, server):　　　　接收请求request，客户端地址client_address，自定义server
        self.request = request　　　　　　　　　　　　　　　　　　　分别赋值
        self.client_address = client_address
        self.server = server
 self.setup()　　　　　　　　　　　　　　　　　　　　　　　　　首先执行setup()函数
        try:
 self.handle()　　　　　　　　　　　　　　　　　　　　　　再执行handle()
        finally:
 self.finish()　　　　　　　　　　　　　　　　　　　　　　最后执行finish()

    def setup(self):　　　　　　　　　　　　　　三个函数结构体都为pass ，需要在继承时进行方法重构
        pass

    def handle(self):
        pass

    def finish(self):
        pass


# The following two classes make it possible to use the same service
# class for stream or datagram servers.
# Each class sets up these instance variables:
# - rfile: a file object from which receives the request is read
# - wfile: a file object to which the reply is written
# When the handle() method returns, wfile is flushed properly


class StreamRequestHandler(BaseRequestHandler):

    """Define self.rfile and self.wfile for stream sockets."""

    # Default buffer sizes for rfile, wfile.
    # We default rfile to buffered because otherwise it could be
    # really slow for large data (a getc() call per byte); we make
    # wfile unbuffered because (a) often after a write() we want to
    # read and we need to flush the line; (b) big writes to unbuffered
    # files are typically optimized by stdio even when big reads
    # aren't.
    rbufsize = -1
    wbufsize = 0

    # A timeout to apply to the request socket, if not None.
    timeout = None

    # Disable nagle algorithm for this socket, if True.
    # Use only when wbufsize != 0, to avoid small packets.
    disable_nagle_algorithm = False

    def setup(self):
        self.connection = self.request
        if self.timeout is not None:
 self.connection.settimeout(self.timeout)
        if self.disable_nagle_algorithm:
 self.connection.setsockopt(socket.IPPROTO_TCP,
 socket.TCP_NODELAY, True)
        self.rfile = self.connection.makefile('rb', self.rbufsize)
        self.wfile = self.connection.makefile('wb', self.wbufsize)

    def finish(self):
        if not self.wfile.closed:
            try:
 self.wfile.flush()
            except socket.error:
                # An final socket error may have occurred here, such as
                # the local error ECONNABORTED.
                pass
 self.wfile.close()
 self.rfile.close()


class DatagramRequestHandler(BaseRequestHandler):

    # XXX Regrettably, I cannot get this working on Linux;
    # s.recvfrom() doesn't return a meaningful client address.

    """Define self.rfile and self.wfile for datagram sockets."""

    def setup(self):
        try:
            from cStringIO import StringIO
        except ImportError:
            from StringIO import StringIO
        self.packet, self.socket = self.request
        self.rfile = StringIO(self.packet)
        self.wfile = StringIO()

    def finish(self):
        self.socket.sendto(self.wfile.getvalue(), self.client_address)

服务器类型

5种类型：BaseServer，TCPServer，UnixStreamServer，UDPServer，UnixDatagramServer。 注意：BaseServer不直接对外服务。

服务器对象

• class SocketServer.BaseServer：这是模块中的所有服务器对象的超类。它定义了接口，如下所述，但是大多数的方法不实现，在子类中进行细化。

• BaseServer.fileno()：返回服务器监听套接字的整数文件描述符。通常用来传递给select.select(), 以允许一个进程监视多个服务器。

• BaseServer.handle_request()：处理单个请求。处理顺序：get_request(), verify_request(), process_request()。如果用户提供handle()方法抛出异常，将调用服务器的handle_error()方法。如果self.timeout内没有请求收到， 将调用handle_timeout()并返回handle_request()。

• BaseServer.serve_forever(poll_interval=0.5): 处理请求，直到一个明确的shutdown()请求。每poll_interval秒轮询一次shutdown。忽略self.timeout。如果你需要做周期性的任务，建议放置在其他线程。

• BaseServer.shutdown()：告诉serve_forever()循环停止并等待其停止。python2.6版本。

• BaseServer.address_family: 地址家族，比如socket.AF_INET和socket.AF_UNIX。

• BaseServer.RequestHandlerClass：用户提供的请求处理类，这个类为每个请求创建实例。

• BaseServer.server_address：服务器侦听的地址。格式根据协议家族地址的各不相同，请参阅socket模块的文档。

• BaseServer.socketSocket：服务器上侦听传入的请求socket对象的服务器。

服务器类支持下面的类变量：

• BaseServer.allow_reuse_address：服务器是否允许地址的重用。默认为false ，并且可在子类中更改。

• BaseServer.request_queue_size

请求队列的大小。如果单个请求需要很长的时间来处理，服务器忙时请求被放置到队列中，最多可以放request_queue_size个。一旦队列已满，来自客户端的请求将得到 “Connection denied”错误。默认值通常为5 ，但可以被子类覆盖。

• BaseServer.socket_type：服务器使用的套接字类型; socket.SOCK_STREAM和socket.SOCK_DGRAM等。

• BaseServer.timeout：超时时间，以秒为单位，或 None表示没有超时。如果handle_request()在timeout内没有收到请求，将调用handle_timeout()。

下面方法可以被子类重载，它们对服务器对象的外部用户没有影响。

• BaseServer.finish_request()：实际处理RequestHandlerClass发起的请求并调用其handle()方法。 常用。

• BaseServer.get_request()：接受socket请求，并返回二元组包含要用于与客户端通信的新socket对象，以及客户端的地址。

• BaseServer.handle_error(request, client_address)：如果RequestHandlerClass的handle()方法抛出异常时调用。默认操作是打印traceback到标准输出，并继续处理其他请求。

• BaseServer.handle_timeout()：超时处理。默认对于forking服务器是收集退出的子进程状态，threading服务器则什么都不做。

• BaseServer.process_request(request, client_address) :调用finish_request()创建RequestHandlerClass的实例。如果需要，此功能可以创建新的进程或线程来处理请求,ForkingMixIn和ThreadingMixIn类做到这点。常用。

• BaseServer.server_activate()：通过服务器的构造函数来激活服务器。默认的行为只是监听服务器套接字。可重载。

• BaseServer.server_bind()：通过服务器的构造函数中调用绑定socket到所需的地址。可重载。

• BaseServer.verify_request(request, client_address)：返回一个布尔值，如果该值为True ，则该请求将被处理，反之请求将被拒绝。此功能可以重写来实现对服务器的访问控制。默认的实现始终返回True。client_address可以限定客户端，比如只处理指定ip区间的请求。 常用。

请求处理器

处理器接收数据并决定如何操作。它负责在socket层之上实现协议（i.e., HTTP, XML-RPC, or AMQP)，读取数据，处理并写反应。可以重载的方法如下：

• setup(): 准备请求处理. 默认什么都不做，StreamRequestHandler中会创建文件类似的对象以读写socket.

• handle(): 处理请求。解析传入的请求，处理数据，并发送响应。默认什么都不做。常用变量：self.request，self.client_address，self.server。

• finish(): 环境清理。默认什么都不做，如果setup产生异常，不会执行finish。

通常只需要重载handle。self.request的类型和数据报或流的服务不同。对于流服务，self.request是socket 对象；对于数据报服务，self.request是字符串和socket 。可以在子类StreamRequestHandler或DatagramRequestHandler中重载，重写setup()和finish() ，并提供self.rfile和self.wfile属性。 self.rfile和self.wfile可以读取或写入，以获得请求数据或将数据返回到客户端。