socketserver简化了网络服务器的编写。它有4个类：tcpserver，udpserver，unixstreamserver，unixdatagramserver。这4个类是同步进行处理的，另外通过forkingmixin和threadingmixin类来支持异步。
创建服务器的步骤。首先，你必须创建一个请求处理类，它是baserequesthandler的子类并重载其handle()方法。其次，你必须实例化一个服务器类，传入服务器的地址和请求处理程序类。最后，调用handle_request()(一般是调用其他事件循环或者使用select())或serve_forever()。
集成threadingmixin类时需要处理异常关闭。daemon_threads指示服务器是否要等待线程终止，要是线程互相独立，必须要设置为true，默认是false。
无论用什么网络协议，服务器类有相同的外部方法和属性。
在python3中，本模块为socketserver模块。在python 2中，本模块为socketserver模块。所以在用import导入时，要分情况导入，否则会报错。导入的代码如下：
try:
import socketserver #python 3
except importerror:
import socketserver #python 2
socketserror模块包括许多可以简化tcp、udp、unix域套接字 服务器实现的类。
一、处理程序
要使用本模块，必须定义一个继承于基类baserequesthandler的处理程序类。baserequesthandler类的实例h可以实现以下方法：
1、h.handle() 调用该方法执行实际的请求操作。调用该函数可以不带任何参数，但是几个实例变量包含有用的值。h.request包含请求，h.client_address包含客户端地址，h.server包含调用处理程序的实例。对于tcp之类的数据流服务，h.request属性是套接字对象。对于数据报服务，它是包含收到数据的字节字符串。
2、h.setup() 该方法在handle()之前调用。默认情况下，它不执行任何操作。如果希望服务器实现更多连接设置（如建立ssl连接），可以在这里实现。
3、h.finish() 调用本方法可以在执行完handle()之后执行清除操作。默认情况下，它不执行任何操作。如果setup()和handle()方法都不生成异常，则无需调用该方法。
如果知道应用程序只能操纵面向数据流的连接（如tcp），那么应从streamrequesthandler继承，而不是baserequesthandler。streamrequesthandler类设置了两个属性，h.wfile是将数据写入客户端的类文件对象，h.rfile是从客户端读取数据的类文件对象。
如果要编写针对数据包操作的处理程序并将响应持续返回发送方，那么它应当从datagramrequesthandler继承。它提供的类接口与stramrequesthandler相同。
二、服务器
要使用处理程序，必须将其插入到服务器对象。定义了四个基本的服务器类。
（1）tcpserver(address,handler) 支持使用ipv4的tcp协议的服务器，address是一个（host,port）元组。handler是baserequesthandler或streamrequesthandler类的子类的实例。
（2）udpserver(address,handler) 支持使用ipv4的udp协议的服务器，address和handler与tcpserver中类似。
（3）unixstreamserver(address,handler) 使用unix域套接字实现面向数据流协议的服务器，继承自tcpserver。
（4）unixdatagramserver(address,handler) 使用unix域套接字实现数据报协议的服务器，继承自udpserver。
所有四个服务器类的实例都有以下方法和变量：
1、s.socket 用于传入请求的套接字对象。
2、s.sever_address 监听服务器的地址。如元组（”127.0.0.1″,80）
3、s.requesthandlerclass 传递给服务器构造函数并由用户提供的请求处理程序类。
4、s.serve_forever() 处理无限的请求
5、s.shutdown() 停止serve_forever()循环
6、s.fileno() 返回服务器套接字的整数文件描述符。该方法可以有效地通过轮询操作（如select()函数）使用服务器实例。
三、定义自定义服务器
服务器往往需要特殊的配置来处理不同的网络地址族、超时期、并发和其他功能，可以通过继承上面四个基本服务器类来自行定义。
可以通过混合类获得更多服务器功能，这也是通过进程或线程分支添加并发行的方法。为了实现并发性，定义了以下类：
（1）forkingmixin 将unix进程分支添加到服务器的混合方法，使用该方法可以让服务器服务多个客户。
（2）threadingmixin 修改服务器的混合类，可以使用线程服务多个客户端。
要向服务器添加这些功能，可以使用多重继承，其中首先列出混了类。
由于并发服务器很常用，为了定义它，socketserver预定义了以下服务器类：
（1）forkingudpserver(address,handler)
（2）forkingtcpserver(address,handler)
（3）threadingudpserver(address,handler)
（4）threadingtcpserver(address,handler)
上面有点乱，现总结以下：
socketserver模块中的类主要有以下几个：
1、baseserver 包含服务器的核心功能与混合类（mix-in）的钩子功能。这个类主要用于派生，不要直接生成这个类的类对象，可以考虑使用tcpserver和udpserver类。
2、tcpserver 基本的网络同步tcp服务器
3、udpserver 基本的网络同步udp服务器
4、forkingmixin 实现了核心的进程化功能，用于与服务器类进行混合(mix-in)，以提供一些异步特性。不要直接生成这个类的对象。
5、threadingmixin 实现了核心的线程化功能，用于与服务器类进行混合(mix-in)，以提供一些异步特性。不要直接生成这个类的对象。
6、forkingtcpserver forkingmixin与tcpserver的组合
7、forkingudpserver forkingmixin与udpserver的组合
8、baserequesthandler
9、streamrequesthandler tcp请求处理类的一个实现
10、datastreamrequesthandler udp请求处理类的一个实现
现在繁杂的事务都已经封装到类中了，直接使用类即可。
四、实例
1.使用socketserver模块编写的tcp服务器端代码：
#! /usr/bin/env python
#coding=utf-8
“””使用socketserver来实现简单的tcp服务器”””
from socketserver import (tcpserver,streamrequesthandler as srh)
from time import ctime
class myrequesthandler(srh):
def handle(self):
print “connected from “,self.client_address
self.wfile.write(“[%s] %s” %(ctime(),self.rfile.readline()))
tcpser=tcpserver((“”,10001),myrequesthandler)
print “waiting for connection”
tcpser.serve_forever()
相应的tcp客户端代码：
#! /usr/bin/env python
#coding=utf-8
from socket import *
bufsize=1024
#每次都要创建新的连接
while true:
tcpclient=socket(af_inet,sock_stream)
tcpclient.connect((“localhost”,10001))
data=raw_input(“>”)
if not data:
break
tcpclient.send(“%s\r\n” %data)
data1=tcpclient.recv(bufsize)
if not data1:
break
print data1.strip()
tcpclient.close()
2.异步服务器的实现
threadingmixin的例子：
import socketimport threadingimport socketserverclass threadedtcprequesthandler(socketserver.baserequesthandler):
def handle(self):
data = self.request.recv(1024)
cur_thread = threading.current_thread()
response = “{}: {}”.format(cur_thread.name, data)
self.request.sendall(response)class threadedtcpserver(socketserver.threadingmixin, socketserver.tcpserver):
passdef client(ip, port, message):
sock = socket.socket(socket.af_inet, socket.sock_stream)
sock.connect((ip, port))
try:
sock.sendall(message)
response = sock.recv(1024)
print “received: {}”.format(response)
finally:
sock.close()if __name__ == “__main__”:
# port 0 means to select an arbitrary unused port
host, port = “localhost”, 0
server = threadedtcpserver((host, port), threadedtcprequesthandler)
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