Day5:编写Web框架
前面完成了数据库的部署与操作封装,现在开始进入到服务器方面的工作。我们前面提到了,在本项目中我们引入了异步框架aiohttp,并且他自身提供了一个服务器。aiohttp已经是一个框架了,为什么我们还要再自己实现呢?
原因在于,从框架的使用者的角度来说,aiohttp还是相对比较底层,想要在使用框架时所需要的代码更简洁,就需要我们在aithttp的基础上增添一些其他的公用的功能,封装出更高级的Web框架。Web框架的设计是完全从使用者出发,目的是让框架使用者编写尽可能少的代码。
编写URL处理函数的大致流程
第一步,编写一个用@asyncio.coroutine装饰的函数:
@asyncio.coroutine
def handle_url_xxx(request):
pass
第二步,传入的参数需要自己从request中获取:
url_param = request.match_info['key']
query_params = parse_qs(request.query_string)
最后,需要自己构造Response对象:
text = render('template', data)
return web.Response(text.encode('utf-8'))
这些重复的工作可以由框架完成,我们的目标也是如此。
接下来在coroweb.py中编写框架代码
Http定义了与服务器交互的不同方法,最基本的方法有4种,分别是GET,POST,PUT,DELETE。
URL全称是资源描述符,我们可以这样认为:一个URL地址,它用于描述一个网络上的资源,而HTTP中的GET,POST,PUT,DELETE就对应着对这个资源的查,改,增,删4个操作。
建议:
1、get方式的安全性较Post方式要差些,包含机密信息的话,建议用Post数据提交方式;
2、在做数据查询时,建议用Get方式;而在做数据添加、修改或删除时,建议用Post方式;
要把一个函数映射为一个URL处理函数,我们先定义@get():
def get(path):
'''
Define decorator @get('/path')
'''
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
return func(*args, **kw)
wrapper.__method__ = 'GET'
wrapper.__route__ = path
return wrapper
return decorator
这里得到的get是一个装饰器。这样,一个函数通过@get()的装饰就附带了URL信息。
@post与@get定义类似。
def post(path):
'''
Define decorator @post('/path')
'''
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
return func(*args, **kw)
wrapper.__method__ = 'POST'
wrapper.__route__ = path
return wrapper
return decorator
定义RequestHandler
URL处理函数不一定是一个coroutine,因此我们用RequestHandler()来封装一个URL处理函数。
RequestHandler是一个类,创建的时候定义了_call_()方法,因此可以将其实例视为函数。
RequestHandler目的就是从URL函数中分析其需要接收的参数,从request中获取必要的参数,调用URL函数,然后把结果转换为web.Response对象,这样,就完全符合aiohttp框架的要求
#运用inspect模块,创建几个函数用以获取URL处理函数与request参数之间的关系
def get_required_kw_args(fn): #收集没有默认值的命名关键字参数
args = []
params = inspect.signature(fn).parameters #inspect模块是用来分析模块,函数
for name, param in params.items():
if str(param.kind) == 'KEYWORD_ONLY' and param.default == inspect.Parameter.empty:
args.append(name)
return tuple(args)
def get_named_kw_args(fn): #获取命名关键字参数
args = []
params = inspect.signature(fn).parameters
for name,param in params.items():
if str(param.kind) == 'KEYWORD_ONLY':
args.append(name)
return tuple(args)
def has_named_kw_arg(fn): #判断有没有命名关键字参数
params = inspect.signature(fn).parameters
for name,param in params.items():
if str(param.kind) == 'KEYWORD_ONLY':
return True
def has_var_kw_arg(fn): #判断有没有关键字参数
params = inspect.signature(fn).parameters
for name,param in params.items():
if str(param.kind) == 'VAR_KEYWORD':
return True
def has_request_arg(fn): #判断是否含有名叫'request'参数,且该参数是否为最后一个参数
params = inspect.signature(fn).parameters
sig = inspect.signature(fn)
found = False
for name,param in params.items():
if name == 'request':
found = True
continue #跳出当前循环,进入下一个循环
if found and (str(param.kind) != 'VAR_POSITIONAL' and str(param.kind) != 'KEYWORD_ONLY' and str(param.kind != 'VAR_KEYWORD')):
raise ValueError('request parameter must be the last named parameter in function: %s%s'%(fn.__name__,str(sig)))
return found
#定义RequestHandler,正式向request参数获取URL处理函数所需的参数
class RequestHandler(object):
def __init__(self,app,fn):#接受app参数
self._app = app
self._fn = fn
self._required_kw_args = get_required_kw_args(fn)
self._named_kw_args = get_named_kw_args(fn)
self._has_named_kw_arg = has_named_kw_arg(fn)
self._has_var_kw_arg = has_var_kw_arg(fn)
self._has_request_arg = has_request_arg(fn)
async def __call__(self,request): #__call__这里要构造协程
kw = None
if self._has_named_kw_arg or self._has_var_kw_arg:
if request.method == 'POST': #判断客户端发来的方法是否为POST
if not request.content_type: #查询有没提交数据的格式(EncType)
return web.HTTPBadRequest(text='Missing Content_Type.')#这里被廖大坑了,要有text
ct = request.content_type.lower() #小写
if ct.startswith('application/json'): #startswith
params = await request.json() #Read request body decoded as json.
if not isinstance(params,dict):
return web.HTTPBadRequest(text='JSON body must be object.')
kw = params
elif ct.startswith('application/x-www-form-urlencoded') or ct.startswith('multipart/form-data'):
params = await request.post() # reads POST parameters from request body.If method is not POST, PUT, PATCH, TRACE or DELETE or content_type is not empty or application/x-www-form-urlencoded or multipart/form-data returns empty multidict.
kw = dict(**params)
else:
return web.HTTPBadRequest(text='Unsupported Content_Tpye: %s'%(request.content_type))
if request.method == 'GET':
qs = request.query_string #The query string in the URL
if qs:
kw = dict()
for k,v in parse.parse_qs(qs,True).items(): #Parse a query string given as a string argument.Data are returned as a dictionary. The dictionary keys are the unique query variable names and the values are lists of values for each name.
kw[k] = v[0]
if kw is None:
kw = dict(**request.match_info)
else:
if not self._has_var_kw_arg and self._named_kw_args: #当函数参数没有关键字参数时,移去request除命名关键字参数所有的参数信息
copy = dict()
for name in self._named_kw_args:
if name in kw:
copy[name] = kw[name]
kw = copy
for k,v in request.match_info.items(): #检查命名关键参数
if k in kw:
logging.warning('Duplicate arg name in named arg and kw args: %s' % k)
kw[k] = v
if self._has_request_arg:
kw['request'] = request
if self._required_kw_args: #假如命名关键字参数(没有附加默认值),request没有提供相应的数值,报错
for name in self._required_kw_args:
if name not in kw:
return web.HTTPBadRequest(text='Missing argument: %s'%(name))
logging.info('call with args: %s' % str(kw))
try:
r = await self._fn(**kw)
return r
except APIError as e: #APIError另外创建
return dict(error=e.error, data=e.data, message=e.message)
在上述RequestHandler代码可以看出最后调用URL函数时,URL函数可能会返回一个名叫APIError的错误,它的作用是用来返回诸如账号登录信息的错误,这会在day10编写用户注册API里面讲到。
add_route()与add_static()函数
由于我们现在要建立的的Web框架基于aiohttp框架,所以需要再编写一个add_route函数,用来注册一个URL处理函数,主要用来验证函数是否有包含URL的响应方法与路径信息,以及将函数变为协程。
代码如下:
def add_route(app, fn):
method = getattr(fn, '__method__', None)
path = getattr(fn, '__route__', None)
if path is None or method is None:
raise ValueError('@get or @post not defined in %s.' % str(fn))
if not asyncio.iscoroutinefunction(fn) and not inspect.isgeneratorfunction(fn):
fn = asyncio.coroutine(fn)
logging.info('add route %s %s => %s(%s)' % (method, path, fn.__name__, ', '.join(inspect.signature(fn).parameters.keys())))
app.router.add_route(method, path, RequestHandler(app, fn))
通常add_route()注册会调用很多次,而为了框架使用者更加方便,可以编写了一个可以批量注册的函数,预期效果是:只需向这个函数提供要批量注册函数的文件路径,新编写的函数就会筛选,注册文件内所有符合注册条件的函数。
# 自动把handler模块的所有符合条件的函数注册了:
def add_routes(app, module_name):
n = module_name.rfind('.')
if n == (-1):
mod = __import__(module_name, globals(), locals())
else:
name = module_name[n+1:]
mod = getattr(__import__(module_name[:n], globals(), locals(), [name]), name)
for attr in dir(mod):
if attr.startswith('_'):
continue
fn = getattr(mod, attr)
if callable(fn):
method = getattr(fn, '__method__', None)
path = getattr(fn, '__route__', None)
if method and path:
add_route(app, fn)
然后添加静态文件夹的路径:
def add_static(app):
path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'static')
app.router.add_static('/static/', path)
logging.info('add static %s => %s' % ('/static/', path))
之后,要在主程序app.py的初始化函数init()中添加middleware、jinja2模板和自注册的支持
添加代码如下:
from coroweb import add_routes, add_static
from aiohttp import web
from jinja2 import Environment, FileSystemLoader
app = web.Application(loop=loop, middlewares=[
logger_factory, response_factory
])
init_jinja2(app, filters=dict(datetime=datetime_filter))
add_routes(app, 'handlers')
add_static(app)
其中jinja2模板的初始化也需要我们在app.py中实现:
def init_jinja2(app, **kw):
logging.info('init jinja2...')
options = dict(
autoescape = kw.get('autoescape', True),
block_start_string = kw.get('block_start_string', '{%'),
block_end_string = kw.get('block_end_string', '%}'),
variable_start_string = kw.get('variable_start_string', '{{'),
variable_end_string = kw.get('variable_end_string', '}}'),
auto_reload = kw.get('auto_reload', True)
)
path = kw.get('path', None)
if path is None:
path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates')
logging.info('set jinja2 template path: %s' % path)
env = Environment(loader=FileSystemLoader(path), **options)
filters = kw.get('filters', None)
if filters is not None:
for name, f in filters.items():
env.filters[name] = f
app['__templating__'] = env
其参数中用到的datetime_filter()函数实质是一个拦截器,具体作用在day8中会提及
先给出代码:
def datetime_filter(t):
delta = int(time.time() - t)
if delta < 60:
return u'1分钟前'
if delta < 3600:
return u'%s分钟前' % (delta // 60)
if delta < 86400:
return u'%s小时前' % (delta // 3600)
if delta < 604800:
return u'%s天前' % (delta // 86400)
dt = datetime.fromtimestamp(t)
return u'%s年%s月%s日' % (dt.year, dt.month, dt.day)
middleware
上面的RequestHandler对于URL做了一系列的处理,但是aiohttp框架最终需要的是返回web.Response对象,实现这一步,这里引入aiohttp框架的web.Application()中的middleware参数。
简介:middleware是一种拦截器,一个URL在被某个函数处理前,可以经过一系列的middleware的处理。一个middleware可以改变URL的输入、输出,甚至可以决定不继续处理而直接返回。middleware的用处就在于把通用的功能从每个URL处理函数中拿出来,集中放到一个地方。
当创建web.appliction的时候,可以设置middleware参数,而middleware的设置是通过创建一些middleware factory(协程函数)。这些middleware factory接受一个app实例,一个handler两个参数,并返回一个新的handler。
一个记录URL日志的logger可以简单定义如下:
async def logger_factory(app, handler):
async def logger(request):
logging.info('Request: %s %s' % (request.method, request.path))
# await asyncio.sleep(0.3)
return (await handler(request))
return logger
response这个middleware把返回值转换为web.Response对象再返回,以保证满足aiohttp的要求:
async def response_factory(app, handler):
async def response(request):
logging.info('Response handler...')
r = await handler(request)
if isinstance(r, web.StreamResponse):
return r
if isinstance(r, bytes):
resp = web.Response(body=r)
resp.content_type = 'application/octet-stream'
return resp
if isinstance(r, str):
if r.startswith('redirect:'):
return web.HTTPFound(r[9:])
resp = web.Response(body=r.encode('utf-8'))
resp.content_type = 'text/html;charset=utf-8'
return resp
if isinstance(r, dict):
template = r.get('__template__')
if template is None:
resp = web.Response(body=json.dumps(r, ensure_ascii=False, default=lambda o: o.__dict__).encode('utf-8'))
resp.content_type = 'application/json;charset=utf-8'
return resp
else:
resp = web.Response(body=app['__templating__'].get_template(template).render(**r).encode('utf-8'))
resp.content_type = 'text/html;charset=utf-8'
return resp
if isinstance(r, int) and r >= 100 and r < 600:
return web.Response(r)
if isinstance(r, tuple) and len(r) == 2:
t, m = r
if isinstance(t, int) and t >= 100 and t < 600:
return web.Response(t, str(m))
# default:
resp = web.Response(body=str(r).encode('utf-8'))
resp.content_type = 'text/plain;charset=utf-8'
return resp
return response
在廖雪峰老师提供的源代码中,还有一个叫做data_factory的函数:
async def data_factory(app, handler):
async def parse_data(request):
if request.method == 'POST':
if request.content_type.startswith('application/json'):
request.__data__ = await request.json()
logging.info('request json: %s' % str(request.__data__))
elif request.content_type.startswith('application/x-www-form-urlencoded'):
request.__data__ = await request.post()
logging.info('request form: %s' % str(request.__data__))
return (await handler(request))
return parse_data
不知道老师为什么在教程中没有提及。
以目前水平也难以猜测其作用。
小结
框架这一块比较难以理解,我觉得甚至难于ORM,以至于博客理了一遍之后还是似懂非懂。今天的梳理参考了一位同学的笔记,对我帮助很大,在此表示感谢。原博传送门