(代码缩进有点问题 大家可以看源码)
tornado有许多关于如何处理路由列表的源码分析的博客，关键在与调用了Application.__call__函数,然后遍历路由列表，取出对应的处理类，由于处理类都是RequestHandler类，调用的是父类的_excute()进行响应处理，我们要了解的是__call__函数和什么时候调用了__call__函数
def __call__(self, request):
“””Called by HTTPServer to execute the request.”””
transforms = [t(request) for t in self.transforms]
handler = None
args = []
kwargs = {}
handlers = self._get_host_handlers(request)
if not handlers:
handler = RedirectHandler(
self, request, url=”http://” + self.default_host + “/”)
else:
for spec in handlers:
match = spec.regex.match(request.path)
if match:
handler = spec.handler_class(self, request, **spec.kwargs)
if spec.regex.groups:
# None-safe wrapper around url_unescape to handle
# unmatched optional groups correctly
def unquote(s):
if s is None:
return s
return escape.url_unescape(s, encoding=None,
plus=False)
# Pass matched groups to the handler. Since
# match.groups() includes both named and unnamed groups,
# we want to use either groups or groupdict but not both.
# Note that args are passed as bytes so the handler can
# decide what encoding to use.
if spec.regex.groupindex:
kwargs = dict(
(str(k), unquote(v))
for (k, v) in match.groupdict().items())
else:
args = [unquote(s) for s in match.groups()]
break
if not handler:
if self.settings.get(‘default_handler_class’):
handler_class = self.settings[‘default_handler_class’]
handler_args = self.settings.get(
‘default_handler_args’, {})
else:
handler_class = ErrorHandler
handler_args = dict(status_code=404)
handler = handler_class(self, request, **handler_args)
# If template cache is disabled (usually in the debug mode),
# re-compile templates and reload static files on every
# request so you don’t need to restart to see changes
if not self.settings.get(“compiled_template_cache”, True):
with RequestHandler._template_loader_lock:
for loader in RequestHandler._template_loaders.values():
loader.reset()
if not self.settings.get(‘static_hash_cache’, True):
StaticFileHandler.reset()
handler._execute(transforms, *args, **kwargs)
return handler
当http_server.listen(options.port)启动监听的时候，程序会accept socket.详见netutil.add_accept_handler函数，我们要注意传递的第一个参数_handle_connection是什么，是一个函数，这里先不具体看函数，我们看看到add_accept_handler后是怎么处理这些参数的
def listen(self, port, address=””):
if self.io_loop is None:
self.io_loop = IOLoop.current()
for sock in sockets:
self._sockets[sock.fileno()] = sock
add_accept_handler(sock, self._handle_connection,
io_loop=self.io_loop)
def _handle_connection(self, connection, address):
if self.ssl_options is not None:
assert ssl, “Python 2.6+ and OpenSSL required for SSL”
try:
connection = ssl_wrap_socket(connection,
self.ssl_options,
server_side=True,
do_handshake_on_connect=False)
except ssl.SSLError as err:
if err.args[0] == ssl.SSL_ERROR_EOF:
return connection.close()
else:
raise
except socket.error as err:
if err.args[0] in (errno.ECONNABORTED, errno.EINVAL):
return connection.close()
else:
raise
try:
if self.ssl_options is not None:
stream = SSLIOStream(connection, io_loop=self.io_loop, max_buffer_size=self.max_buffer_size)
else:
stream = IOStream(connection, io_loop=self.io_loop, max_buffer_size=self.max_buffer_size)
self.handle_stream(stream, address)
except Exception:
app_log.error(“Error in connection callback”, exc_info=True)
#这是add_accept_handler(sock, self._handle_connection,io_loop=self.io_loop)
def add_accept_handler(sock, callback, io_loop=None):
“””Adds an `.IOLoop` event handler to accept new connections on “sock“.
When a connection is accepted, “callback(connection, address)“ will
be run (“connection“ is a socket object, and “address“ is the
address of the other end of the connection). Note that this signature
is different from the “callback(fd, events)“ signature used for
`.IOLoop` handlers.
“””
if io_loop is None:
io_loop = IOLoop.current()
def accept_handler(fd, events):
while True:
try:
connection, address = sock.accept()
except socket.error as e:
# EWOULDBLOCK and EAGAIN indicate we have accepted every
# connection that is available.
if e.args[0] in (errno.EWOULDBLOCK, errno.EAGAIN):
return
# ECONNABORTED indicates that there was a connection
# but it was closed while still in the accept queue.
# (observed on FreeBSD).
if e.args[0] == errno.ECONNABORTED:
continue
raise
callback(connection, address)
io_loop.add_handler(sock.fileno(), accept_handler, IOLoop.READ)
add_accept_handler(sock, callback, io_loop=None)函数接受request请求，调用了callback(connection,address)函数并且给IO事件循环注册了一个事件，我们应该知道callback()函数的，就是传递过来的参数_handle_connection（）再看看这个函数做了什么处理分析不管前面做了什么处理，有一句是要执行的self.handle_stream(stream, address)，原来调用了HttpServer的
def handle_stream(self, stream, address):
HTTPConnection(stream, address, self.request_callback,
self.no_keep_alive, self.xheaders, self.protocol)
调用了HTTPConnection对象，很简单，应该只调用了构造方法
看看Httpserver的构造方法
def __init__(self, request_callback, no_keep_alive=False, io_loop=None,
xheaders=False, ssl_options=None, protocol=None, **kwargs):
self.request_callback = request_callback
self.no_keep_alive = no_keep_alive
self.xheaders = xheaders
self.protocol = protocol
TCPServer.__init__(self, io_loop=io_loop, ssl_options=ssl_options,
**kwargs)
def handle_stream(self, stream, address):
HTTPConnection(stream, address, self.request_callback,
self.no_keep_alive, self.xheaders, self.protocol)
request_callback是什么http_server = tornado.httpserver.HTTPServer(Application())这里清楚了是Application()，分析
def __init__(self, stream, address, request_callback, no_keep_alive=False,
xheaders=False, protocol=None):
self.stream = stream
self.address = address
# Save the socket’s address family now so we know how to
# interpret self.address even after the stream is closed
# and its socket attribute replaced with None.
self.address_family = stream.socket.family
self.request_callback = request_callback
self.no_keep_alive = no_keep_alive
self.xheaders = xheaders
self.protocol = protocol
self._clear_request_state()
# Save stack context here, outside of any request. This keeps
# contexts from one request from leaking into the next.
self._header_callback = stack_context.wrap(self._on_headers)
self.stream.set_close_callback(self._on_connection_close)
self.stream.read_until(b”\r\n\r\n”, self._header_callback)
self._header_callback = stack_context.wrap(self._on_headers)这一句很关键，
def _on_headers(self, data):
#省略******
self.request_callback(self._request)
return
self.request_callback(self._request)前面说了，.request_callback=Application()所以request_callback(self._request) = Application()（self._request）类被当做函数调用，所以__call__函数被调用了，就有了路由列表处理的操作，比较绕啊
