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

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

There are four basic server classes: TCPServer uses the Internet TCP protocol, which provides for continuous streams of data between the client and server. UDPServer uses datagrams, which are discrete packets of information that may arrive out of order or be lost while in transit. The more infrequently used UnixStreamServer and UnixDatagramServer classes are similar, but use Unix domain sockets; they’re not available on non-Unix platforms. For more details on network programming, consult a book such as W. Richard Steven’s UNIX Network Programming or Ralph Davis’s Win32 Network Programming.

这 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 服务器类中简单重复。

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 attributes also change the behavior of the underlying server mechanism.

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

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

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

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

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

21.21.2. 服务器对象 ¶

class socketserver. BaseServer ¶

BaseServer. fileno ( ) ¶

BaseServer. handle_request ( ) ¶

BaseServer. serve_forever ( poll_interval=0.5 ) ¶

BaseServer. service_actions ( ) ¶

BaseServer. shutdown ( ) ¶

BaseServer. server_close ( ) ¶

BaseServer. address_family ¶

BaseServer. RequestHandlerClass ¶

BaseServer. server_address ¶

BaseServer. socket ¶

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

BaseServer. allow_reuse_address ¶

BaseServer. request_queue_size ¶

BaseServer. socket_type ¶

BaseServer. timeout ¶

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

BaseServer. finish_request ( ) ¶

BaseServer. get_request ( ) ¶

BaseServer. handle_error ( request , client_address ) ¶

BaseServer. handle_timeout ( ) ¶

BaseServer. process_request ( request , client_address ) ¶

BaseServer. server_activate ( ) ¶

BaseServer. server_bind ( ) ¶

BaseServer. verify_request ( request , client_address ) ¶

21.21.3. RequestHandler Objects ¶

The request handler class must define a new handle() method, and can override any of the following methods. A new instance is created for each request.

RequestHandler. finish ( ) ¶

RequestHandler. handle ( ) ¶

RequestHandler. setup ( ) ¶: 被调用先于 handle() 方法以履行要求的任何初始化动作。默认实现什么都不做。

21.21.4. 范例 ¶

21.21.4.1. `socketserver.TCPServer` 范例 ¶

这是服务器侧：

import socketserver
class MyTCPHandler(socketserver.BaseRequestHandler):
    """
    The RequestHandler 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)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
    # 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")
finally:
    sock.close()
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):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((ip, port))
    try:
        sock.sendall(bytes(message, 'ascii'))
        response = str(sock.recv(1024), 'ascii')
        print("Received: {}".format(response))
    finally:
        sock.close()
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. RequestHandler Objects ¶

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.1. Server Creation Notes ¶

21.21.2. 服务器对象 ¶

21.21.3. RequestHandler Objects ¶

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` 范例 ¶