Socket网络编程-SocketServer

　　　　　　　　　　　　Socket网络编程-SocketServer

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.SocketServer概述

　　socket编程过于底层，编程虽然有套路，但是想要写出健壮的代码还是比较困难的，所以很多语言都对 socket底层API进行封装，Python的封装就是socketserver模块。它是网络服务编程框架，便于企业级 快速开发。

　　类的继承关系如下所示: 
　　　　+------------+
　　　　| BaseServer |
　　　　+------------+
　　　　|
　　　　|
 　　　　     v
　　　　+-----------+        +--------------------+
　　　　| UDPServer |------->| UnixDatagramServer |
　　　　+-----------+        +--------------------+
　　　　      v
　　　　+-----------+
　　　　                     +------------------+
　　　　| TCPServer |------->| UnixStreamServer |
　　　　+-----------+        +------------------+
 
　　SocketServer简化了网络服务器的编写。 它有4个同步类:
　　　　TCPServer
　　　　UDPServer 
　　　　UnixStreamServer 
　　　　UnixDatagramServer。

　　2个Mixin类:ForkingMixIn 和 ThreadingMixIn 类，用来支持异步。由此得到
　　　　class ForkingUDPServer(ForkingMixIn, UDPServer): pass 
　　　　class ForkingTCPServer(ForkingMixIn, TCPServer): pass
　　　　class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass 
　　　　class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

　　fork是创建多进程，thread是创建多线程。 

　　fork需要操作系统支持，Windows不支持。

二.编程接口

1>.创建服务器需要几个步骤

　　从BaseRequestHandler类派生出子类，并覆盖其handle()方法来创建请求处理程序类，此方法将 处理传入请求
　　
　　实例化一个服务器类，传参服务器的地址和请求处理类

　　调用服务器实例的handle_request()或serve_forever()方法

　　调用server_close()关闭套接字

2>.案例展示

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie


import threading
import socketserver
import logging

FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)

"""
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()

参数说明:
    它是和用户连接的用户请求处理类的基类
    服务端Server实例接收用户请求后，最后会实例化这个类。
    它被初始化时，送入3个构造参数:request, client_address, server自身 
    以后就可以在BaseRequestHandler类的实例上使用以下属性:
        self.request是和客户端的连接的socket对象 
        self.server是TCPServer实例本身 
        self.client_address是客户端地址
    这个类在初始化的时候，它会依次调用3个方法。子类可以覆盖这些方法。
"""
class MyHandler(socketserver.BaseRequestHandler):
    def handle(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 = ('172.30.1.2', 9999)

"""
    将ThreadingTCPServer换成TCPServer，同时连接2个客户端观察效果。 ThreadingTCPServer是异步的，可以同时处理多个连接。
    TCPServer是同步的，一个连接处理完了，即一个连接的handle方法执行完了，才能处理另一个连接， 且只有主线程。
"""
server = socketserver.ThreadingTCPServer(addr, MyHandler)       #注意参数是MyHandler类
server.serve_forever()                                          #永久循环执行

  

三.实现EchoServer(顾名思义，Echo，来什么消息回显什么消息 客户端发来什么信息，返回什么信息) 

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie


import threading
import socketserver

class Handler(socketserver.BaseRequestHandler):
    def setup(self):
        super().setup()
        self.event = threading.Event()
        
    def finish(self):
        super().finish()
        self.event.set()
        
    def handle(self):
        super().handle()
        print('-' * 30)
        while not self.event.is_set():
            data = self.request.recv(1024).decode()
            print(data)
            msg = '{} {}'.format(self.client_address, data).encode()
            self.request.send(msg)

server = socketserver.ThreadingTCPServer(('172.30.1.2', 9999), Handler)
print(server)
threading.Thread(target=server.serve_forever, name='EchoServer', daemon=True).start()

while True:
    cmd = input('>>')
    if cmd == 'quit':
        server.server_close()
        break
    print(threading.enumerate())

四.实战—改写ChatServer 

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie


import datetime
import threading
from socketserver import ThreadingTCPServer, StreamRequestHandler
import logging

FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)

"""
    注意:此程序线程不安全
"""
class ChatHandler(StreamRequestHandler):
    clients = {}

    def setup(self):
        super().setup()
        self.event = threading.Event()
        self.clients[self.client_address] = self.wfile

    def handle(self):
        super().handle()
        # for k,v in self.__dict__.items():
        #     print(k, type(v), v)

        while not self.event.is_set():
            data = self.rfile.read1(1024) # 可以读取到数据
            data = data.decode().rstrip()
            print(data, '~~~~~~~~~~~~~')

            if data == 'quit' or data == '': # 主动退出和断开
                break

            msg = '{} {}:{} {}'.format(datetime.datetime.now(), *self.client_address,data)

            for f in self.clients.values():
                f.write(msg.encode())
                f.flush()

    def finish(self):
        self.clients.pop(self.client_address)
        super().finish()
        self.event.set()

server = ThreadingTCPServer(('172.30.1.2', 9999), ChatHandler)
server.daemon_threads = True # 让所有启动线程都为daemon

threading.Thread(target=server.serve_forever, name='chatserver', daemon=True).start()

while True:
    cmd = input('>>')
    if cmd.strip() == 'quit':
        server.server_close()
        break
    print(threading.enumerate())

五.总结

　　为每一个连接提供RequestHandlerClass类实例，依次调用setup、handle、finish方法，且使用了try...finally结构保证finish方法一定能被调用。这些方法依次执行完成，如果想维持这个连接和客户端 通信，就需要在handle函数中使用循环。

　　socketserver模块提供的不同的类，但是编程接口是一样的，即使是多进程、多线程的类也是一样，大 大减少了编程的难度。 将socket编程简化，只需要程序员关注数据处理本身，实现Handler类就行了。这种风格在Python十分常见。