此时服务器启动poo对象在等待客户端有链接请求服务器
当client发送请求时先创建链接app
event_pairs = self._impl.poll(poll_timeout)socket
此时event_pairs 中保存了事件函数
fd, events = self._events.popitem()oop
try:this
fd_obj, handler_func = self._handlers[fd]spa
handler_func(fd_obj, events)orm
此时的fd为 监听的fd，调用监听对象的回调函数，也就是accept_handlerserver
看 accept_handler代码：对象
def accept_handler(fd, events):
for i in xrange(_DEFAULT_BACKLOG):
try:
connection, address = sock.accept()
except socket.error as e:
# _ERRNO_WOULDBLOCK indicate we have accepted every
# connection that is available.
if errno_from_exception(e) in _ERRNO_WOULDBLOCK:
return
# ECONNABORTED indicates that there was a connection
# but it was closed while still in the accept queue.
# (observed on FreeBSD).
if errno_from_exception(e) == errno.ECONNABORTED:
continue
raise
callback(connection, address)
先调用accept获取客户端链接对象而后调用callback，此时callback是：
_handle_connection，也就是 TCPServer::_handle_connection,不考虑https链接
建立一个IOStream对象，而后调用 handle_stream，此时的handle_stream其实是
HTTPServer::handle_stream，而后建立一个对应的链接对象HTTP1ServerConnection
_connections 中保存该对象，调用对象的start_serving方法
先看 start_serving 方法：
def start_serving(self, delegate):
"""Starts serving requests on this connection.
:arg delegate: a `.HTTPServerConnectionDelegate`
"""
assert isinstance(delegate, httputil.HTTPServerConnectionDelegate)
self._serving_future = self._server_request_loop(delegate)
# Register the future on the IOLoop so its errors get logged.
self.stream.io_loop.add_future(self._serving_future,
lambda f: f.result())
这个函数的参数实际上就是 httpserver对象
调用了_server_request_loop，
在 _server_request_loop 中用@gen.coroutine进行了装饰
@gen.coroutine
def _server_request_loop(self, delegate):
此时的
request_delegate = delegate.start_request(self, conn)
实际调用的是
HTTPServer::start_request
调用 _ServerRequestAdapter
在 _ServerRequestAdapter::__init__中， 调用
server.request_callback.start_request(connection)
Application::start_request 返回_RequestDispatcher，结果就是
request_delegate 指向的对象为 _RequestDispatcher
而后在 gen.coroutine 中调用 _make_coroutine_wrapper，在_make_coroutine_wrapper中
调用yielded = next(result)时，调用的就是
_server_request_loop中的conn.read_response(request_delegate)
此时传入的参数实际上就是RequestDispatcher
而后调用_read_message
而后调用delegate.finish() == _RequestDispatcher::finish()
调用 self.execute()
流程代码：
self.handler = self.handler_class(self.application, self.request,
**self.handler_kwargs)
self.handler._execute(transforms, *self.path_args, **self.path_kwargs)
在 _execute 中调用
result = method(*self.path_args, **self.path_kwargs)
在上面的demo的get方法中，咱们调用self.write("0")，在write的方法中
实际只是把内容放在writebuffer中
self._write_buffer.append(chunk)
而后调用self.finish()
其中调用了self.flush(include_footers=True)
调用
self.request.connection.write_headers(
start_line, self._headers, chunk, callback=callback)
或者
Self.request.connection.write
而后调用self.request.finish()
而后调用HTTP1Connection::finish()
而后调用 HTTP1Connection::_finish_request()
而后判断是否须要断开链接
if not self.is_client and self._disconnect_on_finish:
self.close()
return