socket编程过于底层， 编程虽然有套路，但是想要写出健壮的代码还是比较困难的，所以很多语言都对socket底层api进行封装，Python的封装就是——socketserver模块。它是网络服务编程框架，便于企业级快速开发。
类的继承关系
socketserver简化了网络服务器的编写。
他有四个同步类：TCPServer，UDPServer,UNIXStreamServer,UNIXDatagramServer。
2个mixin类，ForKingMIXIN.和ThreadingMixln类，用来支持异步。
class ForkingUDPServer(ForkingMixln,UDPServer):pass
class ForkingTCPServer(ForkingMixln,TCPServer):pass
class ThreadingUDPServer(ThreadingMixln,UDPServer):pass
class ThreadingTCPServer(ThreadingMixln,TCPServer):pass
fork创建多进程，thread是创建多线程。
编程接口
socketserver.BaseServer(server_address,RequestHandlerClass)
需要提供服务器绑定的地址信息，和用于处理请求的RequestHandlerClass类。
RequestHandlerClass类必须是BaseRequestHandler类的子类，在BaseServer中代码如下：
BaseRequestHandler类
它是和用户连接的用户请求处理类的基类，定义为BaseRequestHandler（request，client_address,server)
服务端server实例接收用户晴请求后，最后会实例化这个类。
它被初始化时，送入3个构造参数，request，client_address,server自身。
以后就可以在BaseRequestHandler类的实例上使用以下属性：
self.request是和客户端的链接的socket对象
self.server是TCPServer本身
self.client_address是客户端地址
这个类在初始化的时候，它会依次调用3个方法。子类可以覆盖这些方法。
import socketserver class MyHandler(socketserver.BaseRequestHandler): def handle(self): super().handle() #todo print("come") addr = ("127.0.0.1",9999) server = socketserver.ThreadingTCPServer(addr,MyHandler) server.serve_forever() server.server_close()
上面的代码运行起来，测试可以看到服务已经启动起来了。处于监听的状态。
再继续修改代码。
import socketserver import threading class MyHandler(socketserver.BaseRequestHandler): def setup(self): super().setup() self.event = threading.Event() def handle(self): super().handle() print(self.server,self.client_address,self.request) while not self.event.wait(1): print("come") addr = ("127.0.0.1",9999) server = socketserver.ThreadingTCPServer(addr,MyHandler) server.serve_forever() server.server_close() 结果为： <socketserver.ThreadingTCPServer object at 0x00000000026BA8D0> ('127.0.0.1', 55533) <socket.socket fd=212, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9999), raddr=('127.0.0.1', 55533)>
在继续修改代码、
import socketserver import threading class MyHandler(socketserver.BaseRequestHandler): def setup(self): super().setup() self.event = threading.Event() def handle(self): super().handle() print(self.server,self.client_address,self.request) while not self.event.is_set(): data = self.request.recv(1024) print(data) addr = ("127.0.0.1",9999) server = socketserver.ThreadingTCPServer(addr,MyHandler) server.serve_forever() server.server_close()
上面的代码运行起来，由小工具发送数据就可以直接显示了。
import socketserver import threading class MyHandler(socketserver.BaseRequestHandler): def setup(self): super().setup() self.event = threading.Event() def handle(self): super().handle() print(self.server,self.client_address,self.request) while not self.event.is_set(): data = self.request.recv(1024) msg = "your msg = {}".format(data.decode()).encode() print(data) self.request.send(msg) addr = ("127.0.0.1",9999) server = socketserver.ThreadingTCPServer(addr,MyHandler) server.serve_forever() server.server_close()
上面就可以回消息了。上面可以连接几个客户端。
测试代码
import threading import socketserver class MyHandler(socketsever.BasequestHandler): def handler(self): #super().handle()可以不调用，父类handle什么都没有做 print("_"*30) print(self.server)#服务 print(self.request)#服务端复制客户端链接请求的socket对象 print(self.client_address)#客户端地址 print(self.__dict__) print(self.server.__dict__)#能看到负责accept的socket print(threading.enumerate()) print(threading.current_thread()) print("-"*30) addr = ("192.168.142.1",9999) server = socketserver.ThreadingTCPServer(addr,MyHandler) server.serve_forever()#永久
测试结果说明，handle方法相当于socket的recv方法。
每个不同的链接上的请求过来后，生成这个链接的socket对象即self.request，客户端渎职是self.client_address。
问题
测试过程中，上面代码，连接后立即断开了，为什么？
怎么样才能客户端和服务器端长时间连接
import threading import socketserver import logging logging.bacicConfig(level = logging.INFO,format = "%(asctime)s %(threadName)s %(thread)d %(message)s") class MyHandler(socketsever.BaseRequestHandler): def handler(self): #super().handle()可以不调用，父类handle什么都没有做 print("_"*30) print(self.server)#服务 print(self.request)#服务端复制客户端链接请求的socket对象 print(self.client_address)#客户端地址 print(self.__dict__) print(self.server.__dict__)#能看到负责accept的socket print(threading.enumerate()) print(threading.current_thread()) print("-"*30) for i in range(3): data = self.request.recv(1024) logging.info(data) logging.info("====end====") addr = ("192.168.142.1",9999) server = socketserver.ThreadingTCPServer(addr,MyHandler) server.serve_forever()#永久
将ThreadingTCPServer换成TCPServer,同时连接2个客户端观察效果。
ThreadingTCPServer是异步的，可以同时处理多个连接。
TCPServer是同步的，一个连接处理完了，即一个连接的handle方法执行完了，才能处理另一个连接，且只有主线程。
总结
创建服务器需要几个步骤
- 从BaseRequestHandler类派生出子类，并覆盖起handle方法来创建请求处理程序类，此方法将处理传入请求。
- 实例化一个服务器类，传参服务器的地址和请求处理类。
- 调用服务器实例的handle_request（）或serve——forever()方法。
- 调用server_close()关闭套接字
实现EchoServer
顾名思义，Echo，来什么消息回显什么消息。
客户端发来什么消息，返回什么消息。
import threading from socketserver import ThreadingTCPServer,BaseRequestHandler import sys class EchoHandler(BaseRequestHandler): def setup(self): super().setup() self.event = threading.Event()#初始化工作 def finish(self): super().finish() self.event.set() def handle(self): super().handle() while not self.event.is_set(): data = self.request.recv(1024).decode() msg = "{} {}".format(self.client_address,data).encode() self.request.send(msg) print("end") addr = ("127.0.0.1",9999) server = ThreadingTCPServer(addr,EchoHandler) server_thread = threading.Thread(target=server.serve_forever,name="echoserver",daemon=True) server_thread.start() try: while True: cmd = input(">>>>>") if cmd.strip() =="quit": break print(threading.enumerate()) except Exception as e: print(e) except KeyboardInterrupt: pass finally: print("exit") sys.exit(0)
上面的代码启动起来，就可以回显消息了，主程序不会有任何显示。
#小工具结果 10:38:59 发送数据：123[1次] 10:38:59 收到数据：('127.0.0.1', 51338) 123 10:39:11 发送数据：xpffsw [1次] 10:39:11 收到数据：('127.0.0.1', 51338) xpffsw
练习——改写ChatServer
使用ThreadingTCPServer改写ChatServer
import threading from socketserver import ThreadingTCPServer,BaseRequestHandler import sys import logging FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s" logging.basicConfig(format=FORMAT,level=logging.INFO) class ChatHandler(BaseRequestHandler): clients = {} def setup(self): super().setup() self.event = threading.Event()#初始工作 self.clients[self.client_address] = self.request def finish(self): super().finish()#清理工作 self.clients.pop(self.client_address)#能执行到吗？ self.event.set() def handle(self): super().handle() while not self.event.is_set()： data = self.request.recv(1024).decode() if data == "quit": break msg = "{} {}".format(self.client_address,data).encode() logging.info(msg) for c in self.clients.values(): self.request.send(msg) print("end") addr =("0.0.0.0",9999) server = ThreadingTCPServer(addr,ChatHandler) server_thread = threading.Thread(target=server.serve_forever,name="chatserver",daemon=True) server_thread.start() try: while True: cmd = input(">>>") if cmd.strip()== "quit": break print(threading.enumerate()) except Exception as e: print(e) except KeyboardInterrupt: pass finally: print("exit") sys.exit(0)
问题，self.clients.pop(self.client_address)#能执行到吗？
如果连接的线程中handle方法中抛出异常，例如客户端主动断开导致的异常，线程崩溃，self.clients的pop方法还能执行吗？
当然能执行，基类源码保证了即使异常，也能执行finish方法。但不代表不应该捕获客户端各种异常。
解决客户端主动连接断开问题
import threading from socketserver import ThreadingTCPServer,BaseRequestHandler import sys import logging FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s" logging.basicConfig(format=FORMAT,level=logging.INFO) class ChatHandler(BaseRequestHandler): clients = {} def setup(self): super().setup() self.event = threading.Event()#初始工作 self.clients[self.client_address] = self.request def finish(self): super().finish()#清理工作 self.clients.pop(self.client_address)#能执行到吗？ self.event.set() def handle(self): super().handle() while not self.event.is_set(): data = self.request.recv(1024).decode() print(data,"____________________")#增加 if data == "quit": break msg = "{} {}".format(self.client_address,data).encode() logging.info(msg) for c in self.clients.values(): print("++++++++++++++")#增加 self.request.send(msg) print("end") addr =("0.0.0.0",9999) server = ThreadingTCPServer(addr,ChatHandler) server_thread = threading.Thread(target=server.serve_forever,name="chatserver",daemon=True) server_thread.start() try: while True: cmd = input(">>>") if cmd.strip()== "quit": break print(threading.enumerate()) except Exception as e: print(e) except KeyboardInterrupt: pass finally: print("exit") sys.exit(0)
通过打印可以看到，客户端主动断开，会导致recv方法立即返回一个空bytes，并没有同时抛出异常，当循环回到recv这一句的时候就会抛出异常。所以，可以通过判断data数据是否为空来客户端是否断开。
import threading from socketserver import ThreadingTCPServer,BaseRequestHandler import sys import logging FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s" logging.basicConfig(format=FORMAT,level=logging.INFO) class ChatHandler(BaseRequestHandler): clients = {} def setup(self): super().setup() self.event = threading.Event()#初始工作 self.clients[self.client_address] = self.request def finish(self): super().finish()#清理工作 self.clients.pop(self.client_address)#能 执行到吗？ self.event.set() def handle(self): super().handle() while not self.event.is_set() data = self.request.recv(1024).decode() print(data,"____________________")#增加 if not data or data == "quit": print("broken pipe") break msg = "{} {}".format(self.client_address,data).encode() logging.info(msg) for c in self.clients.values(): self.request.send(msg) print("end") addr =("0.0.0.0",9999) server = ThreadingTCPServer(addr,ChatHandler) server_thread = threading.Thread(target=server.serve_forever,name="chatserver",daemon=True) server_thread.start() try: while True: cmd = input(">>>") if cmd.strip()== "quit": break print(threading.enumerate()) except Exception as e: print(e) except KeyboardInterrupt: pass finally: print("exit") sys.exit(0)
上面的代码可以增加一个代码，处理一个异常。
总结：
为每个连接提供RequestHandlerclass类实例，一次调用setup，handle、finish方法，且使用了try……finally结构保证finish方法一定能被调用，这些方法依次执行完成，如果想维持这个连接和客户端通信，就需要在handle函数中使用循环。
socketserver模块提供的不同的类，但是编程接口都是一样的，即便是多进程，多线程的类也是一样，大大减少了编程的难度。