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

+--------------+    +----------------+
| ForkingMixIn |    | ThreadingMixIn |
+--------------+    +----------------+

import socketserver
# 創建一個基于TCP的server對象，并使用BaseRequestHandler處理客戶端發送的消息
server = socketserver.ThreadingTCPServer(("127.0.0.1", 8000), BaseRequestHandler) 
server.serve_forever() # 啟動服務器，

class BaseRequestHandler:

  def __init__(self, request, client_address, server):
    self.request = request
    self.client_address = client_address
    self.server = server
    self.setup()
    try:
      self.handle()
    finally:
      self.finish()
  def setup(self):
    pass

  def handle(self):
    pass

  def finish(self):
    pass

import socketserver
import threading 

class MyRequestHandler(socketserver.BaseRequestHandler):
  """ BaseRequestHandler的實例化方法中，獲得了三個屬性
  self.request = request  # 該線程中與客戶端交互的 socket 對象。
  self.client_address   # 該線程處理的客戶端地址
  self.server = server   # 服務器對象
  """

  def handle(self):
    while True:
      msg = self.request.recv()  # 接受客戶端的數據
      if msg == b"quit" or msg == "": # 退出
        break

      print(msg.decode())
      self.request.send(msg) # 將消息發送回客戶端
  def finish(self):
    self.request.close()    # 關閉套接字
if __name__ == "__main__":
  # 創建一個基于TCP的server對象，并使用BaseRequestHandler處理客戶端發送的消息
  server = socketserver.ThreadingTCPServer(("127.0.0.1", 8000), MyRequestHandler)

  server.serve_forever()  # 啟動服務器

class MyRequestHandle(BaseRequestHandler):
  clients = {} # 在類屬性中記錄所有與客戶端連接socket。
  lock = threading.Lock() # 互斥鎖，各個線程共用

  def setup(self): # 新的用戶連接時，預處理，將這個新的連接加入到clients中，考慮線程安全，需要加鎖
    with self.lock:
      self.clients[self.client_address] = self.request

  def handle(self): # 處理客戶端的請求主邏輯
    while True:
      data = self.request.recv(1024).strip()  # 接受數據

      if data == b"quit" or data == b"": # 客戶端退出
        with self.lock:
          self.server.clients.pop(self.client_address)
          self.request.close()
          break

      print("{}-{}: {}".format(*self.client_address, data.decode()))

      with self.lock:
        for _, c in self.server.clients.items(): # 群發
          c.send(data)
  def finish(self):
    with server.lock:
      for _, c in server.clients.items():
        c.close()
    server.server_close()def main():
  server = ThreadingTCPServer(("127.0.0.1", 8000), MyRequestHandle)
  # 將創建的所有線程設置為daemon線程，這樣控臺主程序退出時，這個服務器的所有線程將會被結束
  server.daemon_threads = True 

if __name__ == "__main__":
  main()

class StreamRequestHandler(BaseRequestHandler):
  rbufsize = -1 # 讀緩存
  wbufsize = 0  # 寫緩存
  timeout = None # 超時時間
  # IP/TCP擁塞控制的Nagle算法算法。
  disable_nagle_algorithm = False

  def setup(self): # 實現了setup，
    self.connection = self.request
    if self.timeout is not None:
      self.connection.settimeout(self.timeout)
    if self.disable_nagle_algorithm:
      self.connection.setsockopt(socket.IPPROTO_TCP,
                    socket.TCP_NODELAY, True)
    
    # 使用 makefile方法獲得了一個只讀文件對象 rfile
    self.rfile = self.connection.makefile('rb', self.rbufsize)
    
    # 獲得一個只寫的文件對象 wfile
    if self.wbufsize == 0:
      self.wfile = _SocketWriter(self.connection)
    else:
      self.wfile = self.connection.makefile('wb', self.wbufsize)

  def finish(self): # 負責將這個 wfile 和 rfile方法關閉。
    if not self.wfile.closed: 
      try:
        self.wfile.flush()
      except socket.error:
        pass
    self.wfile.close()
    self.rfile.close()

class MyHandle(StreamRequestHandler):
  # 如果需要使用setup和finish方法，需要調用父類方法，否則該方法將會被覆蓋。
  def setup(self):
    super().setup()
    # 添加自己的需求
  def handle(self):
    # 這里我們可以使用wfile和rfile來處理socket消息了，例如之前使用self.request.recv()方法等同于self.rfile.read()
    # 而 self.wfile.write 等同于 self.request.send()，在handle方法中完成業務邏輯即可

  def finish(self):
    super().finish()

server = ThreadingTCPServer("127.0.0.1", MyHandle)
server.serve_forever()

class DatagramRequestHandler(BaseRequestHandler):

  def setup(self):
    from io import BytesIO
    # udp的self.request包含兩部分（data，socket）它來自于
    # data, client_addr = self.socket.recvfrom(self.max_packet_size)
    #   return (data, self.socket), client_addr
    # （data, self.socket）就是這個self.request，在這里將其解構，data為recvfrom接收的數據
    self.packet, self.socket = self.request
    
    # 該數據包封裝為 BytesIO，同樣為一個類文件對象。
    self.rfile = BytesIO(self.packet)
    self.wfile = BytesIO()

  def finish(self):
    self.socket.sendto(self.wfile.getvalue(), self.client_address)