21.21. `socketserver` — 网络服务器框架 ¶

The socketserver 模块简化编写网络服务器的任务。

有 4 个基本具体服务器类：

class socketserver. TCPServer ( server_address , RequestHandlerClass , bind_and_activate=True ) ¶

class socketserver. UDPServer ( server_address , RequestHandlerClass , bind_and_activate=True ) ¶

class socketserver. UnixStreamServer ( server_address , RequestHandlerClass , bind_and_activate=True ) ¶
class socketserver. UnixDatagramServer ( server_address , RequestHandlerClass , bind_and_activate=True ) ¶

这 4 个类处理请求同步；每个请求必须在下一个请求启动之前完成。这不合适若每个请求花很长时间才完成，因为它要求大量计算，或者因为它返回客户端处理缓慢的大量数据。解决方案是创建单独进程 (或线程) 以处理每个请求; ForkingMixIn and ThreadingMixIn 混合类可以用于支持异步行为。

创建服务器要求几个步骤。首先，必须创建请求处理程序类通过子类化 BaseRequestHandler 类并覆写其 handle() method; this method will process incoming requests. Second, you must instantiate one of the server classes, passing it the server’s address and the request handler class. Then call the handle_request() or serve_forever() 方法在服务器对象以处理一个或多个请求。最后，调用 server_close() to close the socket.

当继承自 ThreadingMixIn 为线程化连接行为，应明确声明想要线程在突然关闭时的行为如何。 ThreadingMixIn 类定义属性 daemon_threads 指示服务器是否应该等待线程终止。应明确设置标志，若愿意让线程行为自主；默认为 False ，意味着 Python 不会退出，直到创建所有线程通过 ThreadingMixIn 的退出。

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

21.21.1. Server Creation Notes ¶

在继承简图中有 5 个类，其中 4 个表示 4 种类型的同步服务器：

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

注意， UnixDatagramServer 派生自 UDPServer ，不是来自 UnixStreamServer — IP 和 Unix 流服务器之间的唯一差异是地址族，在两个 Unix 服务器类中简单重复。

class socketserver. ForkingMixIn ¶
class socketserver. ThreadingMixIn ¶

class socketserver. ForkingTCPServer ¶
class socketserver. ForkingUDPServer ¶
class socketserver. ThreadingTCPServer ¶
class socketserver. ThreadingUDPServer ¶

要实现服务，必须派生类从 BaseRequestHandler 并重新定义其 handle() 方法。然后，可以运行服务的各种版本通过组合某一服务器类与请求处理程序类。请求处理程序类必须不同，对于数据报 (或流) 服务。可以隐藏这通过使用处理程序子类 StreamRequestHandler or DatagramRequestHandler .

当然，仍必须动动脑筋！例如，使用分叉服务器没有意义若服务在内存中包含可以被不同请求修改的状态，由于子级进程中的修改从不会到达父级进程中保持的初始状态，并传递给各子级。在此情况下，可以使用线程服务器，但可能必须使用锁来保护共享数据的完整性。

另一方面，若正构建所有数据存储在外部 (例如，在文件系统中) 的 HTTP 服务器，同步类基本上会使服务 "置若罔闻" 当要处理某个请求时 – 可能持续很长时间，若客户端缓慢接收它所请求的所有数据。在这里，线程化 (或分叉) 服务器是合适的。

在某些情况下，同步处理请求部分可能是合适的，但要基于请求数据在分叉子级中完成处理。这可以通过使用同步服务器实现，并做明确分叉在请求处理程序类 handle() 方法。

同时处理多个请求的另一方式若环境既不支持线程也不支持 fork() (太昂贵或不适合服务)，是维护已部分完成请求的明确表格，和使用 selectors 决定接下来要处理哪个请求 (或是否要处理新的传入请求)。这对流服务尤其重要，当各客户端可以潜在连接很长时间 (若无法使用线程或子进程)。见 asyncore 了解管理这的另一方式。

21.21.2. 服务器对象 ¶

class socketserver. BaseServer ( server_address , RequestHandlerClass ) ¶

fileno ( ) ¶

handle_request ( ) ¶

serve_forever ( poll_interval=0.5 ) ¶

service_actions ( ) ¶

shutdown ( ) ¶

server_close ( ) ¶

address_family ¶

RequestHandlerClass ¶

server_address ¶

socket ¶

服务器类支持下列类变量：

allow_reuse_address ¶

request_queue_size ¶

socket_type ¶

timeout ¶

有各种服务器方法可以覆盖，被子类化的基服务器类像 TCPServer ；这些方法没用，对于服务器对象的外部用户。

finish_request ( ) ¶: 实际处理请求通过实例化 RequestHandlerClass 并调用其 handle() 方法。

get_request ( ) ¶: 必须接受来自套接字的请求，且返回的 2 元素元组包含 new 套接字对象用于与客户端通信，和客户端地址。

handle_error ( request , client_address ) ¶: 此函数被调用若 handle() 方法对于 RequestHandlerClass instance raises an exception. The default action is to print the traceback to standard output and continue handling further requests.

handle_timeout ( ) ¶: 此函数被调用当 timeout 属性有设置值除了 None 且超时周期已过去但没有收到请求。分叉服务器的默认动作是收集已退出的任何子级进程的状态，而在线程服务器中，此方法什么都不做。

process_request ( request , client_address ) ¶: 调用 finish_request() 以创建实例化的 RequestHandlerClass 。若期望，此函数可以创建新的进程 (或线程) 来处理请求； ForkingMixIn and ThreadingMixIn 类会这样做。

server_activate ( ) ¶: 被调用通过服务器的构造函数来激活服务器。TCP 服务器的默认行为仅仅援引 listen() 在服务器的套接字中。可能被覆盖。

server_bind ( ) ¶: 被调用通过服务器的构造函数将套接字绑定到期望地址。可能被覆盖。

verify_request ( request , client_address ) ¶: 必须返回布尔值；若值为 True ，请求将被处理，和若它为 False ，请求将被拒绝。可以覆盖此函数以实现对服务器的访问控制。默认实现始终返回 True .

21.21.3. 请求处理程序对象 ¶

class socketserver. BaseRequestHandler ¶: 这是所有请求处理程序对象的超类。它定义了接口，下文给出。具体请求处理程序子类必须定义新的 handle() 方法，且可以覆盖任何其它方法。为每个请求创建新的子类实例。

setup ( ) ¶

handle ( ) ¶

此函数必须做服务请求要求的所有工作。默认实现什么都不做。它有几个可用实例属性；可用的请求如 self.request ；客户端地址如 self.client_address ；和服务器实例如 self.server ，若它需要访问每台服务器的信息。

类型对于 self.request 是不同的对于数据报 (或流服务)。对于流服务而言， self.request 是套接字对象；对于数据报服务， self.request 是字符串和套接字对。

finish ( ) ¶: 被调用后于 handle() 方法以履行要求的任何清理动作。默认实现什么都不做。若 setup() 引发异常，此函数将不被调用。

class socketserver. StreamRequestHandler ¶
class socketserver. DatagramRequestHandler ¶: 这些 BaseRequestHandler 子类覆盖 setup() and finish() 方法，和提供 self.rfile and self.wfile 属性。 self.rfile and self.wfile 属性可以分别读取或写入，以获取请求数据或将数据返回给客户端。

21.21.4. 范例 ¶

21.21.4.1. `socketserver.TCPServer` 范例 ¶

这是服务器侧：

import socketserver
class MyTCPHandler(socketserver.BaseRequestHandler):
    """
    The request handler class for our server.
    It is instantiated once per connection to the server, and must
    override the handle() method to implement communication to the
    client.
    """
    def handle(self):
        # self.request is the TCP socket connected to the client
        self.data = self.request.recv(1024).strip()
        print("{} wrote:".format(self.client_address[0]))
        print(self.data)
        # just send back the same data, but upper-cased
        self.request.sendall(self.data.upper())
if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    # Create the server, binding to localhost on port 9999
    server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)
    # Activate the server; this will keep running until you
    # interrupt the program with Ctrl-C
    server.serve_forever()

利用流的替代请求处理程序类 (通过提供标准文件接口简化通信的像文件对象)：

class MyTCPHandler(socketserver.StreamRequestHandler):
    def handle(self):
        # self.rfile is a file-like object created by the handler;
        # we can now use e.g. readline() instead of raw recv() calls
        self.data = self.rfile.readline().strip()
        print("{} wrote:".format(self.client_address[0]))
        print(self.data)
        # Likewise, self.wfile is a file-like object used to write back
        # to the client
        self.wfile.write(self.data.upper())

差异是 readline() 在第 2 个处理程序中的调用将调用 recv() 多次直到遇到换行符，而单个 recv() 在第 1 个处理程序中的调用将仅仅返回从客户端发送的内容在某一 sendall() 调用。

这是客户端侧：

import socket
import sys
HOST, PORT = "localhost", 9999
data = " ".join(sys.argv[1:])
# Create a socket (SOCK_STREAM means a TCP socket)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    # Connect to server and send data
    sock.connect((HOST, PORT))
    sock.sendall(bytes(data + "\n", "utf-8"))
    # Receive data from the server and shut down
    received = str(sock.recv(1024), "utf-8")
print("Sent:     {}".format(data))
print("Received: {}".format(received))

范例输出内容看起来应该像这样:

服务器：

$ python TCPServer.py
127.0.0.1 wrote:
b'hello world with TCP'
127.0.0.1 wrote:
b'python is nice'

客户端：

$ python TCPClient.py hello world with TCP
Sent:     hello world with TCP
Received: HELLO WORLD WITH TCP
$ python TCPClient.py python is nice
Sent:     python is nice
Received: PYTHON IS NICE

21.21.4.2. `socketserver.UDPServer` 范例 ¶

这是服务器侧：

import socketserver
class MyUDPHandler(socketserver.BaseRequestHandler):
    """
    This class works similar to the TCP handler class, except that
    self.request consists of a pair of data and client socket, and since
    there is no connection the client address must be given explicitly
    when sending data back via sendto().
    """
    def handle(self):
        data = self.request[0].strip()
        socket = self.request[1]
        print("{} wrote:".format(self.client_address[0]))
        print(data)
        socket.sendto(data.upper(), self.client_address)
if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    server = socketserver.UDPServer((HOST, PORT), MyUDPHandler)
    server.serve_forever()

这是客户端侧：

import socket
import sys
HOST, PORT = "localhost", 9999
data = " ".join(sys.argv[1:])
# SOCK_DGRAM is the socket type to use for UDP sockets
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# As you can see, there is no connect() call; UDP has no connections.
# Instead, data is directly sent to the recipient via sendto().
sock.sendto(bytes(data + "\n", "utf-8"), (HOST, PORT))
received = str(sock.recv(1024), "utf-8")
print("Sent:     {}".format(data))
print("Received: {}".format(received))

范例输出看起来应该准确像 TCP 服务器范例。

21.21.4.3. Asynchronous Mixins ¶

要构建异步处理程序，使用 ThreadingMixIn and ForkingMixIn 类。

范例对于 ThreadingMixIn 类：

import socket
import threading
import socketserver
class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
    def handle(self):
        data = str(self.request.recv(1024), 'ascii')
        cur_thread = threading.current_thread()
        response = bytes("{}: {}".format(cur_thread.name, data), 'ascii')
        self.request.sendall(response)
class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
    pass
def client(ip, port, message):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        sock.connect((ip, port))
        sock.sendall(bytes(message, 'ascii'))
        response = str(sock.recv(1024), 'ascii')
        print("Received: {}".format(response))
if __name__ == "__main__":
    # Port 0 means to select an arbitrary unused port
    HOST, PORT = "localhost", 0
    server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
    ip, port = server.server_address
    # Start a thread with the server -- that thread will then start one
    # more thread for each request
    server_thread = threading.Thread(target=server.serve_forever)
    # Exit the server thread when the main thread terminates
    server_thread.daemon = True
    server_thread.start()
    print("Server loop running in thread:", server_thread.name)
    client(ip, port, "Hello World 1")
    client(ip, port, "Hello World 2")
    client(ip, port, "Hello World 3")
    server.shutdown()
    server.server_close()

范例输出内容看起来应该像这样:

$ python ThreadedTCPServer.py
Server loop running in thread: Thread-1
Received: Thread-2: Hello World 1
Received: Thread-3: Hello World 2
Received: Thread-4: Hello World 3

The ForkingMixIn class is used in the same way, except that the server will spawn a new process for each request.

21.21. socketserver — 网络服务器框架 ¶

21.21.1. Server Creation Notes ¶

21.21.2. 服务器对象 ¶

21.21.3. 请求处理程序对象 ¶

21.21.4. 范例 ¶

21.21.4.1. socketserver.TCPServer 范例 ¶

21.21.4.2. socketserver.UDPServer 范例 ¶

21.21.4.3. Asynchronous Mixins ¶

内容表

上一话题

下一话题

本页

21.21. `socketserver` — 网络服务器框架 ¶

21.21.4.1. `socketserver.TCPServer` 范例 ¶

21.21.4.2. `socketserver.UDPServer` 范例 ¶