serversocket的源码

 点进去看ThreadingTCPServer中是否有__init___

class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
#ThreadingTCPServer 什么也没干,只继承了两个类,去自己的父类里找,从左到右

 

class ThreadingMixIn:
    """Mix-in class to handle each request in a new thread."""

    # Decides how threads will act upon termination of the
    # main process
    daemon_threads = False
　　　#方法一
    def process_request_thread(self, request, client_address):
        """Same as in BaseServer but as a thread.

        In addition, exception handling is done here.

        """
        try:
            self.finish_request(request, client_address)
        except Exception:
            self.handle_error(request, client_address)
        finally:
            self.shutdown_request(request)
　　　#方法二
    def 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
        t.start()

 没有__init__,接着找下一个类里的

class TCPServer(BaseServer): ,看有没有__init__  继承了baseserver

 def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
        """Constructor.  May be extended, do not override."""
        BaseServer.__init__(self, server_address, RequestHandlerClass)
　　　　　#调用了父类的__init__,这样除了父类里的__init__可以用,自己也可以再加一些,下面有base里的__init
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)   #创建套接字对象
        if bind_and_activate:
            try:
                self.server_bind()
                self.server_activate()
            except:
                self.server_close()
                raise

 

BaseServer里的__init__

server=socketserver.ThreadingTCPServer(("127.0.0.1",8899),Myserver)实例化对象

 def __init__(self, server_address, RequestHandlerClass):
        """Constructor.  May be extended, do not override."""
        self.server_address = server_address    #('127.0.0.1',8899)
        self.RequestHandlerClass = RequestHandlerClass   #Myserver
        self.__is_shut_down = threading.Event()
        self.__shutdown_request = False

 class TCPServer(BaseServer) __init__下面的代码

server=socketserver.ThreadingTCPServer(("127.0.0.1",8899),Myserver)实例化对象

if bind_and_activate:
            try:
                self.server_bind()    #相当于以前的server.bind()
　　　　　　　　　#此时的self是ThreadingTCPServer类的对象所以要从头开始找头没有去父类里找,这个在tcpserver中有

　　　　　　　　　　self.server_activate() 
　　　　　　　　　#accepet except: self.server_close() raise

 TPCServer

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

        May be overridden.

        """
        if self.allow_reuse_address:
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.socket.bind(self.server_address)#只能看懂这句,就看这句,
　　　　　　#self.address=('127.0.0.1',8000)

        self.server_address = self.socket.getsockname()

 

TPCServer

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

        May be overridden.

        """
        self.socket.listen(self.request_queue_size)   

 

server_forever

try:
            # 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)

                while not self.__shutdown_request:
                    ready = selector.select(poll_interval)
                    if ready:
                        self._handle_request_noblock()
#先去ThreadingMixIn里找没有去TCPServer里找一定要注意self是

#此时的self是ThreadingTCPServer类的对象所以要从头开始找头没有去父类里找,这个在tcpserver的父类base中找到的

self.service_actions()

 

BaseServer

 def _handle_request_noblock(self):
        """Handle one request, without blocking.

        I assume that selector.select() has returned that the socket is
        readable before this function was called, so there should be no risk of
        blocking in get_request().
        """
        try:
            request, client_address = self.get_request()
　　　　　　　#此结论由下面return得到的,request=conn,clience_addres=addr
　　　　　#续  因为直接粘窜行

        except OSError:
            return
        if self.verify_request(request, client_address):
            try:
                self.process_request(request, client_address)
　　　　　　　　　#还是从头开始找在TheadingPCTServer中找到

　　　　　except Exception:
                self.handle_error(request, client_address)
                self.shutdown_request(request)
            except:
                self.shutdown_request(request)
                raise
        else:
            self.shutdown_request(request)

 

　
#在找get_request()还是从头找

在TPCServer中找到的

  def get_request(self):
        """Get the request and client address from the socket.

        May be overridden.

        """
        return self.socket.accept()

 

 self.process_request(request, client_address)
　　　　　　　　　#还是从头开始找在TheadingPCTServer中找到,看不懂制定了一个线程

   def 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
        t.start()

 

 在ThreadingMixIn中

 def process_request_thread(self, request, client_address):
        """Same as in BaseServer but as a thread.

        In addition, exception handling is done here.

        """
        try:
            self.finish_request(request, client_address)
        except Exception:
            self.handle_error(request, client_address)
        finally:
            self.shutdown_request(request)

 

def finish_request(self, request, client_address):
        """Finish one request by instantiating RequestHandlerClass."""
        self.RequestHandlerClass(request, client_address, self)
给self.RequestHandlerClass这个类实例化,这个类在在baseserver中定义了是自己的Myserver
实际上就是给Mysever实例化,实例化则需要执行__init__文件自己没有去父类里找

 

 def __init__(self, request, client_address, server):
        self.request = request
        self.client_address = client_address
        self.server = server
        self.setup()
        try:
            self.handle()   #此时self是Myserver的实例化对象,Mysrever中正好有handle,所以直接执行