#!/usr/bin/env python3
# _*_ coding:utf-8 _*_

 ==== 使用socketserver创建支持多并发性的服务器 TCP协议 ====

import socketserver

class MyServer(socketserver.BaseRequestHandler):
    """自定义类"""

    def handle(self):
        handle处理请求"""
        print("双向链接通道建立完成:",self.request)   对于TCP协议来说，self.request相当于双向链接通道conn，即accept()的第一部分
        客户端的信息是: 对于TCP协议来说，相当于accept()的第二部分，即客户端的ip+port

        while 1:   开始内层通信循环
            try:   # bug修复：针对windows环境
                data = self.request.recv(1024)

                if not data:
                    break   bug修复：针对类UNIX环境

                收到客户机[{0}]的消息:[{1}]".format(self.client_address,data))
                self.request.sendall(data.upper())   #sendall是重复调用send.

            except Exception as e:
                break

        self.request.close()   当出现异常情况下一定要关闭链接


if __name__ == '__main__':
    s1 = socketserver.ThreadingTCPServer((0.0.0.0 公网服务器绑定 0.0.0.0 私网测试为 127.0.0.1
    s1.serve_forever()   启动服务

 ==== 使用socketserver创建支持多并发性的服务器 UDP协议 ====

"""

         由于UDP是基于消息的协议，故根本不用通信循环

        data = self.request[0]   对于UDP协议来说，self.request其实是个元组。第一个元素是消息内容主题（Bytes类型),相当于recvfrom()的第一部分
        server = self.request[1]     第二个元素是服务端本身，即自己

         对于UDP协议来说，相当于recvfrom()的第二部分，即客户端的ip+port

        :
    s1 = socketserver.ThreadingUDPServer(( 启动服务

ForkingUDPServer(ForkingMixIn,UDPServer)

ForkingTCPServer(ForkingMixIn,TCPServer)

ThreadingUDPServer(ThreadingMixIn,UDPServer)

ThreadingTCPServer(ThreadingMixIn,TCPServer)

StreamRequestHandler(BaseRequestHandler)

DatagramRequestHandler(BaseRequestHandler)

socketserver.ThreadingTCPServer(( 　　我们点进（选中上面代码的ThradingTCPServer部分，CTRL+鼠标左键）源码部分，查找其 __init__ 方法：


class ThreadingTCPServer(ThreadingMixIn,1)">pass

 　　看来没有，那么就找第一父类有没有，我们点进去可以看到第一父类ThreadingMixIn也没有__init__方法，看上面的继承关系图可以看出是普通多继承，那么就是广度优先的查找顺序。我们来看第二父类TCPServer中有没有，看来第二父类中是有__init__方法的，我们详细来看。


 TCPServer(BaseServer):

   注释全被我删了，影响视线"""

    address_family = socket.AF_INET    基于网络的套接字家族

    socket_type = socket.SOCK_STREAM   TCP（字节流）协议

    request_queue_size = 5   消息队列最大为5，可以理解为backlog，即半链接池的大小

    allow_reuse_address = False   端口重用默认关闭

    def __init__(self,server_address,RequestHandlerClass,bind_and_activate=True):
        Constructor.  May be extended,do not override.
        BaseServer.__init__(self,RequestHandlerClass)
        self.socket = socket.socket(self.address_family,self.socket_type)
                                    
        可以看见，上面先是调用了父类的__init__方法，然后又实例化出了一个socket对象！所以我们先不着急往下看，先看其父类中的__init__方法。
       
        if bind_and_activate:
            try:
                self.server_bind()
                self.server_activate()
            :
                self.server_close()
                raise

TCPServer中的__init__()

 　　来看一下，BaseServer类中的__init__方法。


 BaseServer:

    注释依旧全被我删了

    timeout = None   这个变量可以理解为超时时间，先不着急说他。先看 __init__ 方法

    
        self.server_address = server_address   即我们传入的 ip+port ("0.0.0.0",6666)
        self.RequestHandlerClass = RequestHandlerClass   即我们传入的自定义类 MyServer
        self.__is_shut_down = threading.Event()   这里可以看到执行了该方法，这里先不详解，因为它是一个事件锁，所以不用管
        self.__shutdown_request = False 

BaseServer中的__init__()

 　　在BaseServer中执行了thrading模块下的Event()方法。我这里还是提一嘴这个方法是干嘛用的，它会去控制线程的启动顺序，这里实例化出的self.__is_shut_down其实就是一把锁，没什么深究的，接下来的文章中我也会写到。我们继续往下看，现在是该回到TCPServer的__init__方法中来了。



   
    address_family = socket.AF_INET      
    allow_reuse_address = False   看这里！！！！
    if bind_and_activate:   在创建完socket对象后就会进行该判断。默认参数bind_and_activate就是为True
            :
                self.server_bind()  现在进入该方法查看细节
                self.server_activate()
            raise

TCPServer中的__init__()

 　　好了，需要找这个self.bind()方法，还是从头开始找。实例本身没有，第一父类ThreadingMixIn也没有，所以现在我们看的是TCPServer的server_bind()方法：


 server_bind(self):
    Called by constructor to bind the socket.

    May be overridden.

    """
    if self.allow_reuse_address:   这里的变量对应 TCPServer.__init__ 上面定义的类方法，端口重用这个。由于是False，所以我们直接往下执行。
        self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    self.socket.bind(self.server_address)   绑定 ip+port 即 ("0.0.0.0",6666)
    self.server_address = self.socket.getsockname()  获取socket的名字 其实还是 ("0.0.0.0",6666)

TCPServer中的server_bind()

 　　现在我们该看TCPServer下的server_activate()方法了。


 server_activate(self):
    Called by constructor to activate the server.

    May be overridden.

    
    self.socket.listen(self.request_queue_size)   其实就是监听半链接池，backlog为5

TCPServer中的server_activate()

 　　这个时候没有任何异常会抛出的，所以我们已经跑完了整个实例化的流程。并将其赋值给s1
 　　现在我们看一下s1的__dict__字典，再接着进行源码分析。


{server_address': (',1)">RequestHandlerClass': <class __main__.MyServer'>,1)">_BaseServer__is_shut_down': <threading.Event object at 0x000002A96A0208E0>,1)">_BaseServer__shutdown_request': False,1)">socket': <socket.socket fd=716,family=AddressFamily.AF_INET,type=SocketKind.SOCK_STREAM,proto=0,laddr=(s1的__dict__

server_forever()启动服务分析
 　　我们接着来看下一条代码。

s1.serve_forever()

 　　还是老规矩，由于s1是ThreadingTCPServer类的实例对象，所以我们去一层层的找serve_forever()，最后在BaseServer类中找到了。


def serve_forever(self,poll_interval=0.5注释被我删了
    self.__is_shut_down.clear()   上面说过了那个Event锁，控制子线程的启动顺序。这里的clear()代表清除，这个不是重点，往下看。
    :
         XXX: Consider using another file descriptor or connecting to the
         socket to wake this up instead of polling. Polling reduces our
         responsiveness to a shutdown request and wastes cpu at all other
         times.
        with _ServerSelector() as selector:  
            selector.register(self,selectors.EVENT_READ) 这里是设置了一个监听类型为读取事件。也就是说当有请求来的时候当前socket对象就会发生反应。

            while not self.__shutdown_request:  为False，会执行，注意！下面都是死循环了！！！
                ready = selector.select(poll_interval)   设置最大监听时间为0.5s
                 bpo-35017: shutdown() called during select(),exit immediately.
                if self. BaseServer类中的类方法，为False，所以不执行这个。
                    break
                if ready:  代表有链接请求会执行下面的方法
                    self._handle_request_noblock()   这儿是比较重要的一个点。我们先来看。

                self.service_actions() 
    finally:
        self.__shutdown_request = False
        self.__is_shut_down.set()  这里是一个释放锁的行为

BaseServer中的serve_forever()

 　　如果有链接请求，则会执行self._handle_request_noblock()方法，它在哪里呢？刚好这个方法就在BaseServer中serve_forever()方法的正下方第4个方法的位置。


 _handle_request_noblock(self):
    :
        request,client_address = self.get_request()   这里的这个方法在TCPServer中，它的return值是 self.socket.accept(),就是就是返回了元组然后被解压赋值了。其实到这一步三次握手监听已经开启了。
     OSError:
        return
    if self.verify_request(request,client_address):  这个是验证ip和port，返回的始终是True
        :
            self.process_request(request,client_address)  request 双向链接通道，client_address客户端ip+port。现在我们来找这个方法。
         Exception:
            self.handle_error(request,client_address)
            self.shutdown_request(request)
        :
            self.shutdown_request(request)
            raise
    :
        self.shutdown_request(request)

BaseServer中的_handle_request_noblock()

 　　现在开始查找self.process_request(request,client_address)该方法，还是先从实例对象本身找，找不到去第一父类找。他位于第一父类ThreadingMixIn中。


 process_request(self,request,client_address):
    Start a new thread to process the request.
    t = threading.Thread(target = self.process_request_thread,args = (request,client_address))   创建子线程！！看这里！
    t.daemon = self.daemon_threads  ThreadingMixIn的类属性，为False
    not t.daemon and self.block_on_close:   第一个值为False，第二个值为True。他们都是ThreadingMixIn的类属性
        if self._threads is None:   会执行
            self._threads = []   创建了空列表
        self._threads.append(t)  将当前的子线程添加至空列表中
    t.start()   开始当前子线程的运行，即运行self.process_request_thread方法

ThreadingMixIn中的process_request()

 　　我们可以看到，这里的target参数中指定了一个方法self.process_request_thread，其实意思就是说当这个线程t在start的时候会去执行该方法。我们看一下它都做了什么，这个方法还是在ThreadingMixIn类中。


 process_request_thread(self,1)">Same as in BaseServer but as a thread.

    In addition,exception handling is done here.

    :
        self.finish_request(request,1)"> 可以看到又执行该方法了，这里我再标注一下，别弄头晕了。request 双向链接通道，client_address客户端ip+port。
     Exception:
        self.handle_error(request,client_address)
    :
        self.shutdown_request(request)   它不会关闭这个线程，而是将其设置为wait()状态。

ThreadingMixIn中的 process_request_thread()

 　　看self.finish_request()方法，它在BaseServer类中


 finish_request(self,1)">Finish one request by instantiating RequestHandlerClass.
    self.RequestHandlerClass(request,client_address,self)   这里是干嘛？其实就是在进行实例化！

BaseServer中的finish_request

 　　self.RequestHandlerClass(request,self)，我们找到self的__dict__字典，看看这个到底是什么东西


{s1的__dict__

 　　可以看到，它就是我们传入的那个类，即自定义的MyServer类。我们把request,以及整个是实例self传给了MyServer的__init__方法。但是我们的MyServer类没有__init__，怎么办呢？去它父类BaseRequestHandler里面找呗。


 BaseRequestHandler:

     request 双向链接通道
        self.client_address = client_address   客户端ip+port
        self.server = server  即 实例对象本身。上面的__dict__就是它的__dict__
        self.setup()  钩子函数，我们可以自己写一个类然后继承`BaseRequestHandler`并覆写其setup方法即可。
        :
            self.handle()   看，自动执行handle
        :
            self.finish()   钩子函数

     setup(self):
        pass

     handle(self):
         finish(self):
        pass

BaseRequestHandler中的__init__

 　　现在我们知道了，为什么一定要覆写handle方法了吧。
socketserver内部调用顺序流程图(基于TCP协议)
实例化过程图解

server_forever()启动服务图解

扩展：验证链接合法性
 　　在很多时候，我们的TCP服务端为了防止网络泛洪可以设置一个三次握手验证机制。那么这个验证机制的实现其实也是非常简单的，我们的思路在于进入通信循环之前，客户端和服务端先走一次链接认证，只有通过认证的客户端才能够继续和服务端进行链接。
　　下面就来看一下具体的实现步骤。


_*_coding:utf-8_*_
__author__ = Linhaifeng'
from socket import *
 hmac,os

secret_key=blinhaifeng bang bang bang conn_auth(conn):
    '''
    认证客户端链接
    :param conn:
    :return:
    '''
    开始验证新链接的合法性)
    msg=os.urandom(32)   新方法，生成32位随机Bytes类型的值
    conn.sendall(msg)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    respone=conn.recv(len(digest))
    return hmac.compare_digest(respone,digest)  对比结果为True或者为False

def data_handler(conn,bufsize=1024 conn_auth(conn):
        该链接不合法,关闭)
        conn.close()
        链接合法,开始通信)
    while True:
        data=conn.recv(bufsize)
        not data:
        conn.sendall(data.upper())

def server_handler(ip_port,bufsize,backlog=5
    只处理链接
    :param ip_port:
    :return:
    '''
    tcp_socket_server=socket(AF_INET,SOCK_STREAM)
    tcp_socket_server.bind(ip_port)
    tcp_socket_server.listen(backlog)
     True:
        conn,addr=tcp_socket_server.accept()
        新连接[%s:%s]' %(addr[0],addr[1]))
        data_handler(conn,bufsize)

:
    ip_port=(127.0.0.1)
    bufsize=1024
    server_handler(ip_port,bufsize)

Server端




    验证客户端到服务器的链接
    :param conn:
    :return:
    
    msg=conn.recv(32)  拿到随机位数
    h=hmac.new(secret_key,msg)  掺盐
    digest=h.digest()
    conn.sendall(digest)

def client_handler(ip_port,1)">):
    tcp_socket_client= True:
        data=input(>>: ).strip()
        continue
        if data == quit':

        tcp_socket_client.sendall(data.encode(utf-8))
        respone=tcp_socket_client.recv(bufsize)
        print(respone.decode())
    tcp_socket_client.close()


    client_handler(ip_port,bufsize)

Client端

 　　到这里已经很简单了，服务器将随机数给客户机发过去，客户机收到后也用自家的盐与随机数加料，再使用digest()将它转化为字节，直接发送了回来然后客户端通过hmac.compare_digest()方法验证两个的值是否相等，如果不等就说明盐不对。客户机不合法服务端将会关闭与该客户机的双向链接通道。
                        
（编辑：李大同）
【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!