虽说用Python编写简单的网络程序很方便，但复杂一点的网络程序还是用现成的框架比较好。这样就可以专心事务逻辑，而不是套接字的各种细节。SocketServer模块简化了编写网络服务程序的任务。同时SocketServer模块也是Python标准库中很多服务器框架的基础。
socketserver模块可以简化网络服务器的编写，Python把网络服务抽象成两个主要的类，一个是Server类，用于处理连接相关的网络操作，另外一个则是RequestHandler类，用于处理数据相关的操作。并且提供两个MixIn 类，用于扩展 Server，实现多进程或多线程。
一、单线程示例
server端和客户端持续聊天的示例，但是同时只能和一个客户端进行通信，并没有并发的效果。
1、服务端代码
from socket import *
ip_port=('127.0.0.1',8880)
tcp_socket_server=socket()
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)
while 1:
conn,addr=tcp_socket_server.accept()
print('客户端',addr)
while 1:
client_data=conn.recv(1024)
if len(client_data)==0:
print("客户端断开连接，等待新的用户连接....")
break
print ("接受数据 >>>",str(client_data,"utf8"))
response=input("响应数据 >>>")
conn.sendall(bytes(response,"utf8"))
conn.close()
2、客户端代码
import socket
ip_port = ('127.0.0.1',8888)
sock = socket.socket()
sock.connect(ip_port)
print ("客户端启动:")
while True:
inp = input('发送数据 >>>')
if inp == 'exit':
break
sock.sendall(bytes(inp,"utf8"))
server_response=sock.recv(1024)
print ("服务端响应数据 >>>",str(server_response,"utf8"))
sock.close()
二、socketserver的使用模式
import socketserver
class MyServer(socketserver.BaseRequestHandler): # 必须继承这个类
def handle(self):
"""
并发的业务逻辑
conn(客户端套接字对象):self.request
:return:
"""
while 1:
client_data=self.request.recv(1024)
if client_data.decode("utf8") == "exit":
print("客户端断开连接，等待新的用户连接....")
break
print("接受数据 >>>",str(client_data, "utf8"))
response=input("响应数据 >>>")
self.request.sendall(bytes(response, "utf8"))
self.request.close()
# 封装TCP协议相关的套接字对象
server = socketserver.ThreadingTCPServer(('127.0.0.1', 8880), MyServer) # 第一个参数是ip+port，第二个参数是类名MyServer
server.serve_forever()1、总结socketserver使用分以下三步：
（1）自定义功能类
class MyServer(socketserver.BaseRequestHandler): # 必须继承这个类
def handle(self):
"""
并发的业务逻辑
conn(客户端套接字对象):self.request
:return:
"""
while 1:
client_data=self.request.recv(1024)
if len(client_data)==0:
print("客户端断开连接，等待新的用户连接....")
break
print ("接受数据 >>>",str(client_data,"utf8"))
response=input("响应数据 >>>")
self.request.sendall(bytes(response,"utf8"))
self.request.close()
（2）封装TCP协议相关的套接字对象
server = socketserver.ThreadingTCPServer(('127.0.0.1', 8880), MyServer) # 第一个参数是ip+port，第二个参数是类名MyServer
（3）调用server.serve_forever()
server.serve_forever()
2、运行客户端服务端显示效果
三、socketserver源码解析
1、socketserver.ThreadingTCPServer源码解析
（1）查看ThreadingTCPServer类
class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
在socketserver.py中查看到这句源码，混合继承了ThreadingMixIn和TCPServer类。根据广度优先先查看左边的类。
（2）查看ThreadingMixIn类
class ThreadingMixIn:
"""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):...
def process_request(self, request, client_address):...
发现这个类并没有__init__方法，只有两个实例方法。因此再回去查看TCPServer类。
（3）查看TCPServer类中的__init__方法
class TCPServer(BaseServer):
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):
"""
构造函数
:param server_address: 接收的要绑定的元组('127.0.0.1', 8880)
:param RequestHandlerClass: 接收功能类MyServer
:param bind_and_activate:
"""
BaseServer.__init__(self, server_address, RequestHandlerClass) # 执行BaseServer的__init__方法
self.socket = socket.socket(self.address_family,
self.socket_type)
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except:
self.server_close()
raise
"""后面代码省略"""
注意__init__方法接收的参数，server_address: 接收的要绑定的元组('127.0.0.1', 8880)；RequestHandlerClass: 接收功能类MyServer。
__init__方法第一步就是执行BaseServer的__init__方法。
（4）查看BaseServer的__init__方法
class BaseServer:
timeout = None
def __init__(self, server_address, RequestHandlerClass):
"""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
"""代码省略"""
可以看到主要是做了一个实例变量赋值
（5）继续解析TCPServer类中的__init__方法
在执行完BaseServer的__init__方法后，接下里开始创建socket对象：
self.socket = socket.socket(self.address_family,
self.socket_type)
socket对象创建完成后，执行socket.bind和socket.listen方法：
class TCPServer(BaseServer):
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
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) # bind元组地址
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) # listen,这里默认值也是5
（6）总结server = socketserver.ThreadingTCPServer(('127.0.0.1', 8880), MyServer) 做的事情
1.self.socket 2.self.socket.bind() 3.self.socket.listen(5)
这三步完成后，初始化也就完成了。
2、server.serve_forever()源码解析
由于server是ThreadingTCPServer的实例对象，因此依次追溯ThreadingTCPServer、ThreadingMixIn、TCPServer、BaseServer类，最终在BaseServer类中找到serve_forever方法。
（1）查看serve_forever方法
class BaseServer:
def serve_forever(self, poll_interval=0.5):
self.__is_shut_down.clear()
try:
with _ServerSelector() as selector: # IO多路复用监听
selector.register(self, selectors.EVENT_READ)
while not self.__shutdown_request: # 也是监听
ready = selector.select(poll_interval)
if ready:
self._handle_request_noblock()
self.service_actions()
finally:
self.__shutdown_request = False
self.__is_shut_down.set()
前面两步都是监听相关的操作，直接查看self._handle_request_noblock()源码。
（2）查看_handle_request_noblock方法
同样是依次追溯各个类，最后在BaseServer类中找到方法：
class BaseServer:
def _handle_request_noblock(self):
try:
request, client_address = self.get_request()
except OSError:
return
if self.verify_request(request, client_address):
try:
self.process_request(request, client_address)
except Exception:
self.handle_error(request, client_address)
self.shutdown_request(request)
except:
self.shutdown_request(request)
raise
else:
self.shutdown_request(request)
（3）查看self.get_request()方法
class TCPServer(BaseServer):
def get_request(self):
"""Get the request and client address from the socket.
May be overridden.
"""
return self.socket.accept()
在这里找到了socket.accept方法，被动接受TCP客户的连接，（阻塞式）等待连接到来。
因此_handle_request_noblock中的request, client_address = self.get_request()：request就是新的套接字对象（conn）,可以用来接收和发送数据；client_address就是连接客户端的地址。
继续查看_handle_request_noblock方法的self.process_request(request, client_address)调用。
（4）查看process_request方法
这里按照查找顺序，在ThreadingMixIn类找到process_request方法。（注意不要找BaseServer里的process_request，它已经被覆盖了）
class ThreadingMixIn:
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()
每来一个用户就开启一个线程，执行self.process_request_thread(request, client_address)方法。
process_request_thread方法也在ThreadingMixIn类中。
（5）查看process_request_thread方法
class ThreadingMixIn:
def process_request_thread(self, request, client_address):
try:
self.finish_request(request, client_address)
except Exception:
self.handle_error(request, client_address)
finally:
self.shutdown_request(request)
按照查找顺序在BaseServer中找到finish_request方法。
（6）查看finish_request方法
class BaseServer:
def finish_request(self, request, client_address):
"""Finish one request by instantiating RequestHandlerClass."""
self.RequestHandlerClass(request, client_address, self)
注意这里的RequestHandlerClass在TCPServer类中的__init__方法执行时，用RequestHandlerClass来接收功能类MyServer。
这里是在调用MyServer类的实例化。
class MyServer(socketserver.BaseRequestHandler): # 必须继承这个类
def handle(self):
"""
并发的业务逻辑
conn(客户端套接字对象):self.request
:return:
"""
while 1:
client_data=self.request.recv(1024)
if client_data.decode("utf8") == "exit":
print("客户端断开连接，等待新的用户连接....")
break
print("接受数据 >>>",str(client_data, "utf8"))
response=input("响应数据 >>>")
self.request.sendall(bytes(response, "utf8"))
self.request.close()
但是这个类并没有__init__方法，因此需要查看它的父类__init__方法。
（7）查看BaseRequestHandler类
class BaseRequestHandler:
def __init__(self, request, client_address, server):
self.request = request # 新的套接字对象（conn）实例变量赋值
self.client_address = client_address # 连接客户端的地址实例变量赋值
self.server = server
self.setup()
try:
self.handle() # 调用自己的handle方法
finally:
self.finish()
在完成新的套接字对象（conn）实例变量赋值和连接客户端的地址实例变量赋值后，调用自己的handle方法。
这个self.handle()调用的不是BaseRequestHandler类的handle方法而是MyServer的handle方法，执行自定义的handle方法。
3、流程图
