Bottle源码阅读笔记（二）：路由

前言

程序收到请求后，会根据URL来寻找相应的视图函数，随后由其生成页面发送回给客户端。其中，不同的URL对应着不同的视图函数，这就存在一个映射关系。而处理这个映射关系的功能就叫做路由。路由的实现分为两部分：
1. 生成URL映射关系
2. 根据请求匹配正确的视图函数
本文将围绕这两个部分进行分析。

生成URL映射关系

在Bottle的示例程序中，我们使用@app.route修饰器来将地址'/hello'映射到视图函数hello：

 @app.route('/hello')
 def hello():
     return 'Hello World!'

下面以'/hello'为例子来分析app.route的代码。

 def route(self, path=None, method='GET', callback=None, name=None,
           apply=None, skip=None, **config):
     """
         :param callback: An optional shortcut to avoid the decorator
           syntax. ``route(..., callback=func)`` equals ``route(...)(func)``
     """
     if callable(path): path, callback = None, path
     plugins = makelist(apply)
     skiplist = makelist(skip)
     def decorator(callback):
         if isinstance(callback, basestring): callback = load(callback)
         for rule in makelist(path) or yieldroutes(callback):
             for verb in makelist(method):
                 verb = verb.upper()
                 route = Route(self, rule, verb, callback, name=name,
                               plugins=plugins, skiplist=skiplist, **config)
                 self.add_route(route)
         return callback
     return decorator(callback) if callback else decorator

注意注释和最后一行代码，这种形式的return意味着我们还可以使用app.route('/hello', callback=hello)来实现相同的功能。

route方法将我们定下的路由规则（'/hello')和与之相关的HTTP方法(默认为GET)、使用的插件等参数组合成一个Route路由对象，然后通过Router.add()将这个路由添加到处理映射关系的Router对象中。
Router.add()部分代码：

 def add(self, rule, method, target, name=None):
     # do some something
     if is_static and not self.strict_order:
         self.static.setdefault(method, {})
         self.static[method][self.build(rule)] = (target, None)
         retun
     # dynamic path parse

在Router对象中，它维护着两个字典：static和dyna_route，分别用来存储静态路由和动态路由（动态路由的映射与静态相似，这里按下不表）。以我们的示例程序为例：

static = {
    'GET': {
        '/hello': hello,
    }
}

可以看出，Bottle最终是用一个字典来保存这个映射关系的，而且还添加了对HTTP方法的支持。所以在Bottle文档中看到可以用多个路由装饰器装饰同一个视图函数，也就不足为奇了。

@app.route('/', method='POST')
@app.route('/', method='GET')
@app.route('/hello', method='GET')
def func():
    pass

static = {
    'GET': {
        '/': func,
        '/hello': func,
    }
    'POST': {
        '/': func,
    }
}

现在映射关系生成了，那么程序在处理请求的时候，它的内部是如何实现匹配的呢？

匹配视图函数

这里提个小插曲，之前在我阅读到这部分的时候，我还没有搞清楚WSGI是什么，所以我在分析这一步时并没有从Bottle.__call__开始，而是直接Ctrl+f寻找static来确定这个字典在哪里被调用了。虽然是个笨方法，但好歹找到了答案。:D
在Router.match中，可以找到关于static的调用。match()先是从envrion变量中取出请求的URL和请求方法，然后直接从static中取值。

 def match(self, environ):
     ''' Return a (target, url_agrs) tuple or raise HTTPError(400/404/405). '''
     verb = environ['REQUEST_METHOD'].upper()
     path = environ['PATH_INFO'] or '/'
     target = None
     if verb == 'HEAD':
         methods = ['PROXY', verb, 'GET', 'ANY']
     else:
         methods = ['PROXY', verb, 'ANY']

     for method in methods:
         if method in self.static and path in self.static[method]:
             target, getargs = self.static[method][path]
             return target, getargs(path) if getargs else {}
         elif method in self.dyna_regexes:
             for combined, rules in self.dyna_regexes[method]:
                 match = combined(path)
                 if match:
                     target, getargs = rules[match.lastindex - 1]
                     return target, getargs(path) if getargs else {}

接着我不断在用类似的方法寻找上级调用，最终画出了一个这样的函数调用关系链。

以上内容很好地验证了我们上一篇所说的：请求的信息都存储在envrion中，以及Bottle.__call__是我们阅读源程序的入口。

在处理输出的Bottle._handle()中，找到对应的路由后，直接调用路由的call方法，也就是我们的视图函数hello。

 def _handle(self, envrion):
     route, args = self.router.match(environ)
     return route.call(**args)

错误页面

如果程序出错了，Bottl会显示一个默认的错误页面，例如我们熟悉的404页面。

在Bottle内部，对于错误页面的处理跟普通的页面差不多。在Bottle维护着一个专门处理错误页面映射关系的error_handler字典，不过它的键不是HTTP方法或者URL，而是HTTP错误状态码。
类似地，Bottle有专门的@error装饰器让我们自定义错误页面。

 def error(self, code=500)
     def wrapper(handler):
         self.error_handler[int(code)] = handler
         return handler
     return wrapper

当程序因找不到合适的视图函数，或者其他内部错误，Bottle._handle()会抛出一个HTTPError，然后在Bottle._cast()中会根据错误状态码在error_handler找到对应的错误处理函数，最后将这个结果当作普通页面来处理

 Bottle.wsgi()
     out = self._cast(self._handle(environ))
 Bottle._cast()
     if isinstance(out, HTTPError):
         out = self.error_handler.get(out.status_code, self.default_error_handler)(out)
     return self._cast(out)

最后

Bottle用字典来保存URL映射关系来实现路由和错误页面。现在按照相同的思路，我们来为最简单的WSGI应用添加路由功能和一个简单的错误页面。

 class WSGIApp(object):

     def __init__(self):
         self.routes = {}

     def route(self, path, method='GET'):
         def wrapper(callback):
             self.routes.setdefault(method, {})
             self.routes[method][path] = callback
             return callback
         return wrapper

     def error_handler(self, envrion, start_response):
         out = [b'Somethind Wrong!']
         status = '404 NotFound'
         response_headers = [("content-type", "text/plain")]
         start_response(status, response_headers)
         return out

     def __call__(self, envrion, start_response):
         path = envrion['PATH_INFO']
         method = envrion['REQUEST_METHOD'].upper()
         if method in self.routes and path in self.routes[method]:
             handler = self.routes[method][path]
         else:
             handler = self.error_handler
         return handler(envrion, start_response)

 app = WSGIApp()

 @app.route('/')
 def simple_app(envrion, start_response):
     out = [b'Hello World!']
     status = '200 OK'
     response_headers = [("content-type", "text/plain")]
     start_response(status, response_headers)
     return out

 if __name__ == '__main__':
     from wsgiref.simple_server import make_server
     with make_server('', 8000, app) as httpd:
         print("Server is Running...")
         httpd.serve_forever()