Flask Blueprint源码解读
categories: BaseException, Python, Exception
categories: Flask, Blueprint, source code
Flask - Blueprint 源码解读
rb = Blueprint('rbac', __name__, url_prefix='/fuxi/rbac')
@rb.route('/permission/search', methods=["GET"])
@perm_mg.tag(name='搜索权限')
def search_permission():
schema_res = SearchPermissionSchema().load(request.args)
if schema_res.errors:
raise StandardError(msg=schema_res.err_text)
query_data = PermService.search(schema_res.storage)
return json_response(data=query_data)
app.register_blueprint(rb)
以上述代码为例,探寻Blueprint的调用关系。
Blueprint的定义
rb = Blueprint('rbac', __name__, url_prefix='/fuxi/rbac')
定义在此模块下的Blueprint rb,其中rbac为此蓝图的名称,__name__会获取当前模块的名称,例如当前模块的相对路径为:app/rbac/view/main.py,那么__name__此时就是app.rbac.view.main,这个会结合view_func实现路径到执行函数的映射。
url_prefxi会结合rb.route的第一个参数rule一起构成http请求的请求路径。
rb.route函数
函数的调用路径如下图所示:

route函数实际是一个装饰器。
通常我们写两层层的装饰器都是这么写:
import time
import functools
from config import user_logger
def timeit(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
tic = time.monotonic()
result = func(*args, **kwargs)
toc = time.monotonic()
elapsed_time = toc - tic
method_name = func.__name__
module = func.__module__
class_name = func.__qualname__
user_logger.info(f'{module}.{class_name}.{method_name} {elapsed_time:0.4f} seconds.')
return result
return wrapper
@timeit
def calc_time():
time.sleep(2)
三层的装饰器:
def timeit_with_limit(seconds=1):
def timeit(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
tic = time.monotonic()
result = func(*args, **kwargs)
toc = time.monotonic()
elapsed_time = toc - tic
method_name = func.__name__
module = func.__module__
class_name = func.__qualname__
if elapsed_time > seconds:
user_logger.warn(f' warning {module}.{class_name}.{method_name} {elapsed_time:0.4f} seconds.')
return result
return wrapper
return timeit
@timeit_with_limit()
def calc_time():
time.sleep(2)
但是,如果你不想实际执行函数呢?
可以参考route的写法
def route(self, rule, **options):
def decorator(f):
endpoint = options.pop("endpoint", f.__name__)
self.add_url_rule(rule, endpoint, f, **options)
return f
return decorator
这里只是把f作为参数传递进了self.add_url_rule。
为什么一定要获取到endpoint?目的是为了执行从http请求中url映射到具体的view_func。前面的蓝图获取到了import_name,结合import_name和endpoint就可以定位到具体的view_func。
add_url_rule 函数
add_url_rule实际就干了一件事:构造lambda 函数,将其作为参数传递个self.record函数。
lambda 函数:
lambda s: s.add_url_rule(rule, endpoint, view_func, **options)
record 函数
record 函数更简单了,只有一个函数类型的参数。 去掉源码中的注释和校验,就只调用了一个
def record(self, func):
self.deferred_functions.append(func)
其中,self.deferred_functions是一个list。
执行app.register_blueprint函数
去掉校验后的代码如下:
self.blueprints[blueprint.name] = blueprint # hash 标
# {'rbac': blueprint}
self._blueprint_order.append(blueprint) # 列表
# [blueprint]
first_registration = True
blueprint.register(self, options, first_registration)
实际是调用了blueprint的register函数,将app、options、first_registration作为参数传递进去。
def register(self, app, options, first_registration=False):
self._got_registered_once = True
state = self.make_setup_state(app, options, first_registration) # 构造BlueprintSetupState 实例
if self.has_static_folder:
state.add_url_rule(
self.static_url_path + '/<path:filename>',
view_func=self.send_static_file, endpoint='static'
)
for deferred in self.deferred_functions:
deferred(state)
在上面for 循环中,defrered 实际是上面提到的lambda函数,执行lambda函数。
在lambda函数中,我们看到实际执行的是s.add_url_rule,这里的s对应的就是state,也就是BluePrintSetupState这个类的add_url_rule函数。
源码如下:
def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
# 构造完整的url path,eg: /shanhai/rbac/permission/search
# 其中 /shanhai/rbac 表示url_prefix
# permission/search 表示rule
if self.url_prefix:
rule = self.url_prefix + rule
options.setdefault('subdomain', self.subdomain)
# endpoint 如果为空,指向view_func.__name__
if endpoint is None:
endpoint = _endpoint_from_view_func(view_func)
defaults = self.url_defaults
if 'defaults' in options:
defaults = dict(defaults, **options.pop('defaults'))
# 调用app的add_url_rule
# 参数为rule , endpoint, view_func
# rule: /shanhai/rbac/permission/search
# endpoint: '%s.%s' % (self.blueprint.name, endpoint)
# view_func: view_func
self.app.add_url_rule(rule, '%s.%s' % (self.blueprint.name, endpoint),
view_func, defaults=defaults, **options)
最后就是app.add_url_rule。
关键部分如下:
rule = self.url_rule_class(rule, methods=methods, **options)
rule.provide_automatic_options = provide_automatic_options
self.url_map.add(rule)
if view_func is not None:
... # 检查old_func
# 添加到self.view_functions,这样就可以根据endpoint 找到view_func了
self.view_functions[endpoint] = view_func
现在结合实际的请求,来看下一个真实的请求是如何被处理的。
首先,Flask不建议使用app.run的方式部署在生产环境中,更合适的方式是结合WSGI server的方式部署。
这里为了简单起见,简单介绍下以app.run方式启动的情况下,请求被解析的过程。
调用过程:
app.run->app.run_simple->{server=make_server()'; server.run_forever()}
这样就启动web_service,其中run_forever是一个while 循环。
make_server默认启动 ThreadedWSGIServer,因此,最终也是调用了ThreadedWSGIServer的run_forever()。
ThreadedWSGIServer 的继承关系图如下:

在run_forever -> self._handle_request_noblock-> 调用ThreadingMixIn.process_request
def process_request(self, request, client_address):
"""Start a new thread to process the request."""
# 启动一个线程,调用self.process_request_thread
t = threading.Thread(target = self.process_request_thread, args = (request, client_address))
t.daemon = self.daemon_threads
if not t.daemon and self._block_on_close:
if self._threads is None:
self._threads = []
self._threads.append(t)
t.start()
继续看下 self.process_request_thread的代码:
def process_request_thread(self, request, client_address):
"""Same as in BaseServer but as a thread.
In addition, exception handling is done here.
"""
try:
# 还是调用 self.finish_request
self.finish_request(request, client_address)
except Exception:
self.handle_error(request, client_address)
finally:
self.shutdown_request(request)
finish_request继承自 BaseServer,就是调用了self.RequestHandlerClass,没干别的。
self.finish_request-> self.RequestHandlerClass(request, client_address, self)
self.RequestHandlerClass 这个具体是什么呢?
从继承关系图中可以看到,ThreadWSGIServer继承自BaseWSGIServer,
在BaseWSGIServer的init函数中,handler 是第四个参数,定义了handler:
def __init__(
self,
host: str,
port: int,
app: "WSGIApplication",
handler: t.Optional[t.Type[WSGIRequestHandler]] = None,
passthrough_errors: bool = False,
ssl_context: t.Optional[_TSSLContextArg] = None,
fd: t.Optional[int] = None,
) -> None:
# 如果没有指定,默认为WSGIRequestHandler
if handler is None:
handler = WSGIRequestHandler
.... # 中间代码省略
# 将handler 传给了父类,BaseWSGIServer的父类为`HTTPServer`,但是,HTTPServer 没有初始化函数,HTTPServer继承 TCPServer,所以,再看下TCPServer的初始化函数定义就知道handler就是RequestHandlerClass
# TCPServer的初始化:
# __init__(server_address, RequestHandlerClass, bind_and_activate=True)
super().__init__(server_address, handler)
在前面提到的run_simple函数中,并没有指定handler,所以,self.RequestHandlerClass 实际就是 WSGIRequestHandler。
继续看 WSGIRequestHandler,先来看下 WSGIRequestHandler的继承关系图:
因为在finish_request中只初始化了handler,所以,重点来看下初始化函数 __init__做了哪些事情,在上述的继承关系中,只有基类 BaseRequestHander存在初始化函数,定义如下:
def __init__(self, request, client_address, server):
self.request = request # socket.socket
self.client_address = client_address # 格式如下:('127.0.0.1', 51895)
self.server = server # <werkzeug.serving.ThreadedWSGIServer object at 0x111269550>
self.setup() # 处理socket 的写入和读取
try:
self.handle() # 重点关注这里
finally:
self.finish() # 这里
先看下self.handle函数,这个函数调用的就是WSGIRequestHandler自己的handle函数,但是在这个handle函数实际调用了通过BaseHTTPRequestHandler调用了WSGIRequestHandler的handle_one_request。
终于开始解析请求了,看下 handle_one_request的代码:
def handle_one_request(self) -> None:
"""Handle a single HTTP request."""
self.raw_requestline = self.rfile.readline() # 读取http请求的原始报文数据,例如:
# b'GET /fuxi/rbac/permission/search HTTP/1.1\r\n'
if not self.raw_requestline:
self.close_connection = True
# 非空,解析请求
elif self.parse_request():
self.run_wsgi()
parse_request就是负责解析http 请求数据。而且,不支持 http2.0,但是实际线上环境就是跑在http2.0协议上的,开发环境还是http1.1。(当然这个是基于python3.6.8中http/server.py的代码)
解析结束会对:
- self.command
- self.path
- self.request_version
- self.headers 完成赋值。
解析header会抛出哪些异常?
- LineTooLong(“header line”) 65536 字节
- HTTPException(“got more than %d headers” % _MAXHEADERS) # 最多100个header
# 2.0 协议实现双向通信了,而且默认就是keep-alive
elif (conntype.lower() == 'keep-alive' and
self.protocol_version >= "HTTP/1.1"):
self.close_connection = False
请求解析完成后,进入run_wsgi函数,看下具体做了哪些工作?
- 构造WSGI Environment WSGI Environment 详细信息可以参考 python pep0333
- 调用
execute函数,开始执行flask app 相关的代码,也就是middleware、dispatch_request、view_function 等。try: execute(self.server.app) except (ConnectionError, socket.timeout) as e: self.connection_dropped(e, environ) except Exception: if self.server.passthrough_errors: raise from .debug.tbtools import get_current_traceback
execute 源码:
def execute(app: "WSGIApplication") -> None:
# app 这里就是flask.app了,但是,注意,这里app是instance,而不是class,所以,这里会直接执行flask.app的 __call__函数
#
application_iter = app(environ, start_response)
try:
for data in application_iter:
write(data)
if not headers_sent:
write(b"")
finally:
if hasattr(application_iter, "close"):
application_iter.close() # type: ignore
继续来看flask.app.__call__函数
__call__函数只调用了 self.wsgi_app
wsgi_app函数的源码
ctx = self.request_context(environ)
error = None
try:
try:
ctx.push() # 将请求上下文添加到`_request_ctx_stack`
response = self.full_dispatch_request()
except Exception as e:
error = e
response = self.handle_exception(e)
except:
error = sys.exc_info()[1]
raise
return response(environ, start_response)
finally:
if self.should_ignore_error(error):
error = None
ctx.auto_pop(error)
在flask中,requst是被存储在线程的local(在flask中被封装在LocalStack中)中的,_request_ctx_stack是LocalStack类型的全局变量,request 会被push到_request_ctx_stack。这样,当你直接使用from flask import request; request.xxx时,就能直接找到(见_look_req_object函数 flask/globals.py)。
回到,wsgi_app函数本身,处理完请求上下文之后,开始调度请求,这是通过self.full_dispatch_request函数完成的。
在self.full_dispatch_request中主要完成以下几个事情:
- befor_first_request_functions
- before_request_functions
- 执行dispatch_request
befor_first_request_functions 和 before_request_functions 都是自定义middleware 添加中,所以这里不做过多的解释。 直接看调度请求函数。
self.view_functions[rule.endpoint](**req.view_args)
在app.add_url_rule函数中,会把view_func添加到self.view_functions中,在dispatch_request中通过view_functions找到view_function,执行。
接着就是 finalize_request函数。
从view_func中返回结果会作为finalize_request的参数,接着调用make_response函数构造response。