Tornado 高并发源码分析之四--- HTTPServer 与 TCPServer 对象

主要工作：

服务器启动的时候做的事：

1、把包含了各种配置信息的 application 对象封装到了 HttpServer 对象的 request_callback 字段中，等待被调用

2、TCPServer 通过 listen 方法启动端口监听，封装_handle_connection回调函数，并注册到 IOLoop 中

服务器运行时做的事：

3、当有请求到来时，注册在 IOLoop 中的 _handle_connection 将会被调用， _handle_connection 方法将会调用handle_stream 方法。

4、handle_stream 方法是由 HTTPServer 重写TCPServer的方法，它将会创建 HTTP1ServerConnection对象和_ServerRequestAdapter 对象(这里只是创建好，并没有执行)，并调用 HTTP1ServerConnection 对象的start_serving 方法

5、start_serving 方法创建创建HTTP1Connection 对象，并在方法 _server_request_loop 中异步yield conn.read_response(request_delegate) 接受请求发过来的数据，这里传入的delegate就是在HTTPServer 中创建的_ServerRequestAdapter对象。

4、在异步接收的时候，_ServerRequestAdapter 负责将数据封装成 HTTPRequest 对象，接收完毕之后，调用_ServerRequestAdapter的 finish 方法

5、在调用_ServerRequestAdapter 的 finish 方法时，数据就会调用 application 对象的 __call__ 方法，这时就回到了 Application 类了（这里不解释，直接看Application 的 __call__ 方法）

1、TCPServer 作为工厂类，自身只做统一的端口绑定、监听、回调函数绑定的操作

2、HTTPServer 作为子类，实现数据接收类的创建，接受数据，最后封装成 HTTPRequest 对象，交给Application 对象

3、在整个接收数据的过程中，并不能分辨出 url 是什么，该匹配哪个 handler，这件事是由 Application 对象来处理的

源码分析，省略部分源码，只粘贴出主要部分

 1 class HTTPServer(TCPServer, httputil.HTTPServerConnectionDelegate):
 2 #继承自TCPServer 和 httputil.HTTPServerConnectionDelegate
 3 
 4 def __init__(self, request_callback, no_keep_alive=False, io_loop=None,
 5              xheaders=False, ssl_options=None, protocol=None,
 6              decompress_request=False,
 7              chunk_size=None, max_header_size=None,
 8              idle_connection_timeout=None, body_timeout=None,
 9              max_body_size=None, max_buffer_size=None):
10     self.request_callback = request_callback   #获取 application对象
11     self.no_keep_alive = no_keep_alive
12     self.xheaders = xheaders
13     self.protocol = protocol
14     self.conn_params = HTTP1ConnectionParameters(   #获取基本的http 参数
15         decompress=decompress_request,
16         chunk_size=chunk_size,
17         max_header_size=max_header_size,
18         header_timeout=idle_connection_timeout or 3600,
19         max_body_size=max_body_size,
20         body_timeout=body_timeout)
21     TCPServer.__init__(self, io_loop=io_loop, ssl_options=ssl_options,   传递HTTPServer 给TCPServer对象，初始化
22                        max_buffer_size=max_buffer_size,
23                        read_chunk_size=chunk_size)
24     self._connections = set()
25 
26 def handle_stream(self, stream, address):  
27  #请求到来时，真正的数据处理方法
28     context = _HTTPRequestContext(stream, address,
29                                   self.protocol)
30     conn = HTTP1ServerConnection(   #创建HTTP1ServerConnection对象，用来获取链接
31         stream, self.conn_params, context)
32     self._connections.add(conn)
33     conn.start_serving(self)   #启动获取数据服务， 传递自己为代理
34 
35 def start_request(self, server_conn, request_conn): #将会在handle_stream添加进去的代理中执行
36     return _ServerRequestAdapter(self, request_conn)   #创建_ServerRequestAdapter对象， 开始接受封装数据

HTTPServer

 1 class _ServerRequestAdapter(httputil.HTTPMessageDelegate):
 2     """负责数据流整理，将数据最后封装成 HTTPRequest对象
 3     """
 4     def __init__(self, server, connection):
 5         self.server = server
 6         self.connection = connection
 7         self.request = None
 8         if isinstance(server.request_callback, httputil.HTTPServerConnectionDelegate):
 9             self.delegate = server.request_callback.start_request(connection)
10             self._chunks = None
11         else:
12             self.delegate = None
13             self._chunks = []
14 
15     def headers_received(self, start_line, headers):   #接受请求头部数据
16         if self.server.xheaders:
17             self.connection.context._apply_xheaders(headers)
18         if self.delegate is None:
19             self.request = httputil.HTTPServerRequest(  #创建HTTPServerRequest对象
20                 connection=self.connection, start_line=start_line,
21                 headers=headers)
22         else:
23             return self.delegate.headers_received(start_line, headers)
24 
25     def data_received(self, chunk):  #不停的接受数据，放到_chunks里面
26         if self.delegate is None:
27             self._chunks.append(chunk)
28         else:
29             return self.delegate.data_received(chunk)
30 
31     def finish(self):  #request_callback本身就是一个application对象，在加上括号，那就是执行这个对象，也是就是调用application 的 __call__方法，并传入了封装好的request对象
32         if self.delegate is None:
33             self.request.body = b''.join(self._chunks)
34             self.request._parse_body()
35             self.server.request_callback(self.request)
36         else:
37             self.delegate.finish()
38         self._cleanup()

_ServerRequestAdapter