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

源代码： Lib/socketserver.py

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

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

class socketserver. ForkingMixIn ¶
class socketserver. ThreadingMixIn ¶

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

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 ¶

finish_request ( request , client_address ) ¶

get_request ( ) ¶

handle_error ( request , client_address ) ¶

handle_timeout ( ) ¶

process_request ( request , client_address ) ¶

server_activate ( ) ¶

server_bind ( ) ¶

verify_request ( request , client_address ) ¶

请求处理程序对象 ¶

class socketserver. BaseRequestHandler ¶

setup ( ) ¶

handle ( ) ¶

finish ( ) ¶

class socketserver. StreamRequestHandler ¶
class socketserver. DatagramRequestHandler ¶

范例 ¶

`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
    with socketserver.TCPServer((HOST, PORT), MyTCPHandler) as server:
        # 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

`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
    with socketserver.UDPServer((HOST, PORT), MyUDPHandler) as server:
        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 服务器范例。

异步混合 ¶

要构建异步处理程序，使用 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)
    with server:
        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()

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

$ 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 类使用方式相同，除服务器会为每个请求卵生新的进程外。只可用于 POSIX (便携式操作系统接口) 平台支持 fork() .

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

服务器创建注意事项 ¶

服务器对象 ¶

请求处理程序对象 ¶

范例 ¶

`socketserver.TCPServer` 范例 ¶

`socketserver.UDPServer` 范例 ¶

异步混合 ¶

内容表

上一话题

下一话题

本页

快速搜索

socketserver — 网络服务器框架 ¶

服务器创建注意事项 ¶

服务器对象 ¶

请求处理程序对象 ¶

范例 ¶

socketserver.TCPServer 范例 ¶

socketserver.UDPServer 范例 ¶

异步混合 ¶

内容表

上一话题

下一话题

本页

快速搜索

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

`socketserver.TCPServer` 范例 ¶

`socketserver.UDPServer` 范例 ¶