Methods for the caller:- __init__(server_address, RequestHandlerClass) 　　　　　　　　#初始化 可扩长- serve_forever(poll_interval=0.5)　　　　　　　　　　　　　　　　#被构造函数调用激活服务器- shutdown()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#关闭server_forever循环- handle_request()  # if you do not use serve_forever()   　　#请求处理函数，可能会被阻塞#get_request->verify_request->process_request- fileno() -> int   # for selector                        　　#返回一个整型文件操作符供服务器监听，Methods that may be overridden:- server_bind()　　　　　　　　　　　　　　　　　　　　　　　　　　　#绑定到要监听的地址上- server_activate()　　　　　　　　　　　　　　　　　　　　　　 　　#被构造函数调用激活服务器，- get_request() -> request, client_address　　　　　　　　　　　#获取请求- handle_timeout()　　　　　　　　　　　　　　　　　　　　　　　　　#处理超时- verify_request(request, client_address)　　　　　　　　　 　　#验证请求- server_close()　　　　　　　　　　　　　　　　　　　　　　　　　　#关闭服务器- process_request(request, client_address)　　　　　　　　　　　#进程处理，调用finish_request 完成请求- shutdown_request(request)　　　　　　　　　　　　　　　　　　　　#被shutdown调用，关闭一个单独的请求- close_request(request)　　　　　　　　　　　　　　　　　　　 　　#关闭请求- service_actions()　　　　　　　　　　　　　　　　　　　　　　 　　#被serve_forever 调用- handle_error()　　　　　　　　　　　　　　　　　　　　　　　　 　　#处理错误　

class TCPServer(BaseServer):address_family = socket.AF_INET             　　　　　　　　　　　# 定义地址族，ipv4socket_type = socket.SOCK_STREAM　　　　　　　　　　　　　　　　　　# 定义套接字类型，流式套接字（TCP)　　request_queue_size = 5　　　　　　　　　　　　　　　　　　　　　　　  #定义监听的数量allow_reuse_address = False　　　　　　　　　　　　　　　　　　　　　# 定义是否要设置套接口的选项def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):BaseServer.__init__(self, server_address, RequestHandlerClass) 　　　  　　#调用BaseServer的初始化self.socket = socket.socket(self.address_family,self.socket_type)  　 　　 #创建一个套接字if bind_and_activate:try:self.server_bind()self.server_activate()            　　 　　　　　　　　　　　　　　　　#调用bind（）和activate（） except:　　self.server_close()　　　　　　　　　　　　　　　　　　　　　　　　　 　　#关闭serverraisedef server_bind(self):　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#绑定监听地址if self.allow_reuse_address:self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)   　　#设定socketself.socket.bind(self.server_address)　　　　　　　　　　　　　　　　　　　　 　　#绑定地址self.server_address = self.socket.getsockname()        　　　　　　　　　　　　#获取待连接客户端的地址def server_activate(self):　　　　　　　　　　　　　　　　　　　　　　　　　　　　　self.socket.listen(self.request_queue_size)　　　　　　　　　　　　　　　　　　　#监听　def server_close(self):self.socket.close()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  　　#关闭def fileno(self):return self.socket.fileno()　　　　　　　　　　　　　　　　　　　　　　　　　　　　#文件描述符def get_request(self):return self.socket.accept()　　　　　　　　　　　　　　　　　　　　　　　　　　　　#接受客户端的连接def shutdown_request(self, request):try:request.shutdown(socket.SHUT_WR)　　　　　　　　　　　　　　　　　　　　　　 #关闭之前先调用shutdown保证通信双方数据不丢失except OSError:pass 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #之后再调用closeself.close_request(request)def close_request(self, request):　　　　　　　　　　　　　　　　　　　　　　　　　　　#释放套接字的描述符，直接调用可能丢弃传输队列中的数据request.close()

class BaseRequestHandlerdef __init__(self, request, client_address, server):   　　　　　　#初始化request,client_addres serverself.request = requestself.client_address = client_addressself.server = serverself.setup()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#在handle()方法前调用，初始化所有需要的try:self.handle()finally:self.finish()def setup(self):passdef handle(self):　　　　　　　　　　　　　　　　　　　　　　　　　　　　#具体的处理请求函数，需要被覆盖passdef finish(self):　　　　　　　　　　　　　　　　　　　　　　　　　　　　#在handle()方法好后调用，清理工作passclass StreamRequestHandler(BaseRequestHandler):rbufsize = -1                                          　　　　　　 #为流式套接字定义rfile和wfilewbufsize = 0timeout = Nonedisable_nagle_algorithm = False                　　　　　　　　　　  #当wbufsize !=0才会用到，避免太小的包 def setup(self):self.connection = self.requestif 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)self.rfile = self.connection.makefile('rb', self.rbufsize)    #一个类似文件的对象，可以用来接收客户端的数据self.wfile = self.connection.makefile('wb', self.wbufsize)　　 #一个类似文件的对象，可以向客户端返回数据def finish(self):if not self.wfile.closed:　　　　　　　　　　　　　　　　　　　　   #wfile关闭之前需要刷新try:self.wfile.flush()except socket.error:passself.wfile.close()self.rfile.close()

#server.py
import socketserver
class myTCPHandle(socketserver.StreamRequestHandler):　　　　　　　　　def handle(self):　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#定义自己的请求处理函数　print("connet from %s:%s" % self.client_address)　　　　　　　　 #打印客户端的地址self.data=self.rfile.readline()　　　　　　　　　　　　　　　　　　 #读取客户端的传过来的一行数据print(str(self.data,encoding="utf-8"))self.wfile.write(bytes('你好',encoding='utf-8'))　　　　　　　　　#发送数据‘你好’给客户端
if __name__=='__main__':address=('127.0.0.1',9999)server=socketserver.TCPServer(address,myTCPHandle)　　　　　　　　　　#创建一个基于TCPServer的套接字server.serve_forever()　　　　　　　　　　　　　　　　　　　　　　　　　　#调用它的server_forever()函数处理一个请求直到它被shutdown#client.py
import socket
client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)　　　　　　　　 #创建套接字
client.connect(('127.0.0.1',9999)) 　　　　　　　　　　　　　　　　　　　　#要连接的地址和端口data='hello,server\n'　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #发送的数据 \n作为行结束
data_bytes=bytes(data,encoding="utf-8")　　　　　　　　　　　　　　　　　　#转换成字节发送
client.send(data_bytes)　　　　　　　　　　　　　　　　　　　　　　　　　　　 #发送数据
data_recive=client.recv(1024)　　　　　　　　　　　　　　　　　　　　　　　　#接受数据
print(str(data_recive,encoding='utf-8'))　　　　　　　　　　　　　　　　　 #将接受的数据转换成字符串
client.close()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#关闭套接字

class ThreadingMixIn:daemon_threads = Falsedef process_request_thread(self, request, client_address):  　　　　　　 #处理请求的线程函数try:self.finish_request(request, client_address)self.shutdown_request(request)except:self.handle_error(request, client_address)self.shutdown_request(request)def process_request(self, request, client_address):#生成一个线程t = threading.Thread(target = self.process_request_thread,args = (request, client_address))t.daemon = self.daemon_threadst.start()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #启动线程

# server.py
import socketserver
import threadingclass ThreadingTCPServer(socketserver.ThreadingMixIn,socketserver.TCPServer):  #继承ThreadingMixIn，使其支持多线程passclass myTCPHandle(socketserver.StreamRequestHandler):def handle(self):print("connet from %s:%s" % self.client_address)cur_thread=threading.current_thread()                                  #打印当前处理请求线程的名字self.data=self.rfile.readline()　　　　　　　　　　　　　　　　　　　　　　　 #读取客户端的数据print(cur_thread.name)print(str(self.data,encoding="utf-8"))self.wfile.write(bytes('你好',encoding='utf-8'))    　　　　　　　　　　　#向客户端发送数据if __name__=='__main__':address=('127.0.0.1',9999)server=socketserver.ThreadingTCPServer(address,myTCPHandle)　　　　　　　　 #创建一个支持多线程的socket#server=socketserver.TCPServer(address,myTCPHandle)server.serve_forever()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #调用server_forever（）处理请求直到被shutdown
'''
服务端打印的数据如下：connect from 127.0.0.1：xxxThread-xfrom client：x...
'''#client.py
import socket
for i in range(5):k=socket.socket(socket.AF_INET,socket.SOCK_STREAM)                   #定义了5个套接字，连接服务端，并向他发送数据k.connect(('127.0.0.1',9999))senddata='from client:{}\n'.format(i+1)　　　　　　　　　　　　　　　　　#向服务端发送数据k.send(bytes(senddata,encoding='utf-8'))data_recive=k.recv(1024)print(str(data_recive,encoding='utf-8'))　　　　　　　　　　　　　　　　 #打印从服务端收到的数据 你好k.close()