2. Day 5 - 编写Web框架
    4. 阅读: 84143
    5. 在正式开始Web开发前，我们需要编写一个Web框架。
    7. aiohttp已经是一个Web框架了，为什么我们还需要自己封装一个？
    9. 原因是从使用者的角度来说，aiohttp相对比较底层，编写一个URL的处理函数需要这么几步：
    11. 第一步，编写一个用@asyncio.coroutine装饰的函数：
    13. @asyncio.coroutine
    14. def handle_url_xxx(request):
    15.     pass
    16. 第二步，传入的参数需要自己从request中获取：
    18. url_param = request.match_info['key']
    19. query_params = parse_qs(request.query_string)
    20. 最后，需要自己构造Response对象：
    22. text = render('template', data)
    23. return web.Response(text.encode('utf-8'))
    24. 这些重复的工作可以由框架完成。例如，处理带参数的URL/blog/{id}可以这么写：
    26. @get('/blog/{id}')
    27. def get_blog(id):
    28.     pass
    29. 处理query_string参数可以通过关键字参数**kw或者命名关键字参数接收：
    31. @get('/api/comments')
    32. def api_comments(*, page='1'):
    33.     pass
    34. 对于函数的返回值，不一定是web.Response对象，可以是str、bytes或dict。
    36. 如果希望渲染模板，我们可以这么返回一个dict：
    38. return {
    39.     '__template__': 'index.html',
    40.     'data': '...'
    41. }
    42. 因此，Web框架的设计是完全从使用者出发，目的是让使用者编写尽可能少的代码。
    44. 编写简单的函数而非引入request和web.Response还有一个额外的好处，就是可以单独测试，否则，需要模拟一个request才能测试。
    46. @get和@post
    48. 要把一个函数映射为一个URL处理函数，我们先定义@get()：
    50. def get(path):
    51.     '''
    52.     Define decorator @get('/path')
    53.     '''
    54.     def decorator(func):
    55.         @functools.wraps(func)
    56.         def wrapper(*args, **kw):
    57.             return func(*args, **kw)
    58.         wrapper.__method__ = 'GET'
    59.         wrapper.__route__ = path
    60.         return wrapper
    61.     return decorator
    62. 这样，一个函数通过@get()的装饰就附带了URL信息。
    64. @post与@get定义类似。
    66. 定义RequestHandler
    68. URL处理函数不一定是一个coroutine，因此我们用RequestHandler()来封装一个URL处理函数。
    70. RequestHandler是一个类，由于定义了__call__()方法，因此可以将其实例视为函数。
    72. RequestHandler目的就是从URL函数中分析其需要接收的参数，从request中获取必要的参数，调用URL函数，然后把结果转换为web.Response对象，这样，就完全符合aiohttp框架的要求：
    74. class RequestHandler(object):
    76.     def __init__(self, app, fn):
    77.         self._app = app
    78.         self._func = fn
    79.         ...
    81.     @asyncio.coroutine
    82.     def __call__(self, request):
    83.         kw = ... 获取参数
    84.         r = yield from self._func(**kw)
    85.         return r
    86. 再编写一个add_route函数，用来注册一个URL处理函数：
    88. def add_route(app, fn):
    89.     method = getattr(fn, '__method__', None)
    90.     path = getattr(fn, '__route__', None)
    91.     if path is None or method is None:
    92.         raise ValueError('@get or @post not defined in %s.' % str(fn))
    93.     if not asyncio.iscoroutinefunction(fn) and not inspect.isgeneratorfunction(fn):
    94.         fn = asyncio.coroutine(fn)
    95.     logging.info('add route %s %s => %s(%s)' % (method, path, fn.__name__, ', '.join(inspect.signature(fn).parameters.keys())))
    96.     app.router.add_route(method, path, RequestHandler(app, fn))
    97. 最后一步，把很多次add_route()注册的调用：
    99. add_route(app, handles.index)
    100. add_route(app, handles.blog)
    101. add_route(app, handles.create_comment)
    102. ...
    103. 变成自动扫描：
    105. # 自动把handler模块的所有符合条件的函数注册了:
    106. add_routes(app, 'handlers')
    107. add_routes()定义如下：
    109. def add_routes(app, module_name):
    110.     n = module_name.rfind('.')
    111.     if n == (-1):
    112.         mod = __import__(module_name, globals(), locals())
    113.     else:
    114.         name = module_name[n+1:]
    115.         mod = getattr(__import__(module_name[:n], globals(), locals(), [name]), name)
    116.     for attr in dir(mod):
    117.         if attr.startswith('_'):
    118.             continue
    119.         fn = getattr(mod, attr)
    120.         if callable(fn):
    121.             method = getattr(fn, '__method__', None)
    122.             path = getattr(fn, '__route__', None)
    123.             if method and path:
    124.                 add_route(app, fn)
    125. 最后，在app.py中加入middleware、jinja2模板和自注册的支持：
    127. app = web.Application(loop=loop, middlewares=[
    128.     logger_factory, response_factory
    129. ])
    130. init_jinja2(app, filters=dict(datetime=datetime_filter))
    131. add_routes(app, 'handlers')
    132. add_static(app)
    133. middleware
    135. middleware是一种拦截器，一个URL在被某个函数处理前，可以经过一系列的middleware的处理。
    137. 一个middleware可以改变URL的输入、输出，甚至可以决定不继续处理而直接返回。middleware的用处就在于把通用的功能从每个URL处理函数中拿出来，集中放到一个地方。例如，一个记录URL日志的logger可以简单定义如下：
    139. @asyncio.coroutine
    140. def logger_factory(app, handler):
    141.     @asyncio.coroutine
    142.     def logger(request):
    143.         # 记录日志:
    144.         logging.info('Request: %s %s' % (request.method, request.path))
    145.         # 继续处理请求:
    146.         return (yield from handler(request))
    147.     return logger
    148. 而response这个middleware把返回值转换为web.Response对象再返回，以保证满足aiohttp的要求：
    150. @asyncio.coroutine
    151. def response_factory(app, handler):
    152.     @asyncio.coroutine
    153.     def response(request):
    154.         # 结果:
    155.         r = yield from handler(request)
    156.         if isinstance(r, web.StreamResponse):
    157.             return r
    158.         if isinstance(r, bytes):
    159.             resp = web.Response(body=r)
    160.             resp.content_type = 'application/octet-stream'
    161.             return resp
    162.         if isinstance(r, str):
    163.             resp = web.Response(body=r.encode('utf-8'))
    164.             resp.content_type = 'text/html;charset=utf-8'
    165.             return resp
    166.         if isinstance(r, dict):
    167.             ...
    168. 有了这些基础设施，我们就可以专注地往handlers模块不断添加URL处理函数了，可以极大地提高开发效率。
    170. 参考源码
    172. day-05