Python高级技术之：如何利用`socketserver`库，快速构建`TCP`和`UDP`服务器。

各位观众老爷，晚上好！今天咱们聊聊Python里的socketserver库，这玩意儿能让咱们快速搭建TCP和UDP服务器，省时省力，简直是懒人福音。准备好瓜子板凳，咱们开讲啦！

一、socketserver是啥？为啥要用它？

简单来说，socketserver就是Python提供的一个高级网络编程框架，它封装了socket编程的底层细节，让咱们只需要关注业务逻辑，而不用操心那些复杂的连接建立、数据接收发送、多线程/多进程管理等等。

想象一下，你要开一家小饭馆，如果自己从零开始，得自己买锅碗瓢盆、搭炉灶、买菜、招服务员……累死个人。而socketserver就像一个已经装修好的商业厨房，各种设备一应俱全，你只需要雇个厨师（编写处理请求的handler），就能开门营业了。

用socketserver的好处显而易见：

• 简化开发： 减少了大量重复代码，让咱们专注于处理客户端请求。
• 提高效率： 框架已经处理好了并发连接，咱们不用自己写复杂的线程/进程管理。
• 代码可读性强： 代码结构清晰，易于理解和维护。

二、socketserver的几个核心概念

在使用socketserver之前，咱们需要了解几个重要的概念：

• Server类： 负责监听端口，接收客户端连接，并分配请求给handler处理。socketserver提供了几种Server类，比如TCPServer（TCP服务器）、UDPServer（UDP服务器）、UnixStreamServer、UnixDatagramServer等等。咱们主要讲TCP和UDP。
• RequestHandler类： 负责处理客户端的请求。咱们需要继承这个类，并重写handle()方法，在handle()方法里编写处理请求的具体逻辑。
• ThreadingMixIn和ForkingMixIn： 这两个是混合类（Mixin），用于实现多线程和多进程并发。通过将Server类和这两个Mixin类结合使用，可以创建多线程或多进程的服务器。

可以用一个表格来总结一下：

组件	功能	备注
Server类	监听端口，接收连接，分配请求	如TCPServer、UDPServer
RequestHandler类	处理客户端请求	需要继承并重写handle()方法
ThreadingMixIn	多线程并发	和Server类结合使用，例如class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
ForkingMixIn	多进程并发	和Server类结合使用，例如class ForkingTCPServer(ForkingMixIn, TCPServer): pass

三、手把手教你搭建TCP服务器

咱们先来搭建一个最简单的TCP服务器，它可以接收客户端发来的消息，并原封不动地返回给客户端。

1. 编写RequestHandler：

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 you received.
        self.request.sendall(self.data)

这段代码定义了一个MyTCPHandler类，继承自socketserver.BaseRequestHandler。handle()方法是核心，它做了以下几件事：

• self.request：表示与客户端连接的socket对象。
• self.request.recv(1024)：从客户端接收数据，最多接收1024字节。
• self.data：接收到的数据，并使用strip()方法去除首尾空格。
• self.client_address：客户端的地址信息，是一个元组，包含IP地址和端口号。
• self.request.sendall(self.data)：将接收到的数据原封不动地发送回客户端。

2. 创建TCPServer并启动：

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

这段代码做了以下几件事：

• 定义了服务器的IP地址和端口号。
• 创建了一个TCPServer对象，并将IP地址、端口号和RequestHandler类传递给它。
• 调用server.serve_forever()方法，启动服务器，开始监听端口，接收客户端连接。

把上面两段代码放在同一个文件里，比如tcp_server.py，然后运行它：

python tcp_server.py

服务器就跑起来了。

3. 编写TCP客户端测试：

import socket

HOST, PORT = "localhost", 9999
data = "Hello, Server!"

# 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, "utf-8"))

    # Receive data from the server
    received = str(sock.recv(1024), "utf-8")

print("Sent:     {}".format(data))
print("Received: {}".format(received))

这段代码创建了一个TCP客户端，连接到服务器，发送数据，并接收服务器返回的数据。保存为tcp_client.py，运行它：

python tcp_client.py

你应该能看到类似这样的输出：

Sent:     Hello, Server!
Received: Hello, Server!

同时，在服务器端，你应该能看到客户端的IP地址和发送的数据。

四、手把手教你搭建UDP服务器

UDP服务器的搭建过程和TCP服务器类似，只是Server类和RequestHandler类有所不同。

1. 编写RequestHandler：

import socketserver

class MyUDPHandler(socketserver.BaseRequestHandler):
    """
    This class explains how to handle UDP server requests.
    """

    def handle(self):
        data = self.request[0].strip()
        socket = self.request[1]
        print("{} wrote:".format(self.client_address[0]))
        print(data)
        socket.sendto(data, self.client_address)

和TCPRequestHandler不同的是，UDPRequestHandler的handle()方法接收到的self.request是一个元组，包含两个元素：

• self.request[0]：接收到的数据。
• self.request[1]：socket对象，用于发送数据。

socket.sendto(data, self.client_address)：将数据发送回客户端。

2. 创建UDPServer并启动：

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    with socketserver.UDPServer((HOST, PORT), MyUDPHandler) as server:
        server.serve_forever()

这段代码创建了一个UDPServer对象，并将IP地址、端口号和RequestHandler类传递给它。

把上面两段代码放在同一个文件里，比如udp_server.py，然后运行它：

python udp_server.py

3. 编写UDP客户端测试：

import socket

HOST, PORT = "localhost", 9999
data = "Hello, UDP Server!"

with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
    sock.sendto(bytes(data, "utf-8"), (HOST, PORT))
    received = sock.recvfrom(1024)

print("Sent:     {}".format(data))
print("Received: {}".format(received[0].decode("utf-8")))

注意：UDP客户端使用的是socket.SOCK_DGRAM参数，表示创建一个UDP socket。sock.recvfrom(1024)方法会返回一个元组，包含接收到的数据和发送方的地址信息。

保存为udp_client.py，运行它：

python udp_client.py

你应该能看到类似这样的输出：

Sent:     Hello, UDP Server!
Received: Hello, UDP Server!

五、实现多线程/多进程并发

上面实现的服务器只能处理一个客户端的请求，如果多个客户端同时连接，服务器就会阻塞。为了提高服务器的并发处理能力，咱们可以使用多线程或多进程。

1. 多线程TCP服务器：

import socketserver

class ThreadingTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
    pass

class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        self.data = self.request.recv(1024).strip()
        print("{} wrote:".format(self.client_address[0]))
        print(self.data)
        self.request.sendall(self.data)

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = ThreadingTCPServer((HOST, PORT), MyTCPHandler)
    server.serve_forever()

关键在于定义了一个ThreadingTCPServer类，它继承自socketserver.ThreadingMixIn和socketserver.TCPServer。ThreadingMixIn提供了多线程并发的能力。

2. 多进程TCP服务器：

import socketserver

class ForkingTCPServer(socketserver.ForkingMixIn, socketserver.TCPServer):
    pass

class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        self.data = self.request.recv(1024).strip()
        print("{} wrote:".format(self.client_address[0]))
        print(self.data)
        self.request.sendall(self.data)

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = ForkingTCPServer((HOST, PORT), MyTCPHandler)
    server.serve_forever()

和多线程类似，只需要将ThreadingMixIn替换为ForkingMixIn即可。

选择多线程还是多进程？

这是一个经典问题。简单来说：

• 多线程： 适用于I/O密集型任务，比如网络请求、文件读写等。线程之间共享内存，切换开销小。但由于GIL（全局解释器锁）的存在，在CPU密集型任务中，多线程并不能真正利用多核CPU。
• 多进程： 适用于CPU密集型任务，比如计算、图像处理等。进程之间内存隔离，安全性高。但进程创建和切换开销大。

六、一些高级技巧

1. 设置超时时间：

可以在RequestHandler的setup()方法中设置socket的超时时间：

class MyTCPHandler(socketserver.BaseRequestHandler):
    def setup(self):
        self.request.settimeout(5)  # 设置超时时间为5秒

    def handle(self):
        try:
            self.data = self.request.recv(1024).strip()
            print("{} wrote:".format(self.client_address[0]))
            print(self.data)
            self.request.sendall(self.data)
        except socket.timeout:
            print("Timeout!")

2. 自定义Server类：

可以继承TCPServer或UDPServer类，并重写一些方法，比如server_bind()、server_activate()、get_request()等，来实现更高级的功能。

3. 使用select模块实现非阻塞I/O：

如果需要处理大量的并发连接，可以使用select模块来实现非阻塞I/O，提高服务器的性能。

七、总结

socketserver库是Python中一个非常实用的网络编程框架，它可以帮助咱们快速搭建TCP和UDP服务器，简化开发，提高效率。通过学习本文，你应该已经掌握了socketserver的基本用法，并能够搭建简单的TCP和UDP服务器。

记住，编程就像做菜，熟能生巧。多练习，多实践，你也能成为网络编程的高手！

今天的讲座就到这里，谢谢大家！