python钩子函数装饰器_Flask初探六 ( 请求钩子 / 钩子函数 / 蓝图 )

请求钩子

通过装饰器为一个模块添加请求钩子, 对当前模块的请求进行额外的处理. 比如权限验证.

项目结构

01-项目结构.png

应用钩子函数

E:\workspace\pycharm\Demo\application_init_.py

def create_app(config_name):

app = Flask(__name__)

# config Debug = True

app.config.from_object(config_name)

from modules import blue_index

from modules import blue_user

from modules import blue_admin

app.register_blueprint(blue_index)

app.register_blueprint(blue_user)

app.register_blueprint(blue_admin)

# 钩子函数 before_first_request

@app.before_first_request

def before_first():

print("app.before_first")

# 钩子函数 before_request

@app.before_request

def before():

print("app.before")

# 钩子函数 after_request

@app.after_request

def after(response):

print("app.after")

return response

# 钩子函数 teardown_request

@app.teardown_request

def teardown(e):

print("app.teardown")

return app

E:\workspace\pycharm\Demo\manage.py

from application import create_app

from application.config import *

app = create_app(DevelopmentConfig)

@app.route("/app")

def app_test():

print("app.app_test")

return "app.app_test"

if __name__ == '__main__':

app.run(port=23456)

运行结果

app.before_first

app.before

app.app_test

app.after

app.teardown

127.0.0.1 - - [06/Jul/2018 14:56:25] "GET /app HTTP/1.1" 200 -

根据运行结果, 可以得出钩子函数在一次请求中的执行顺序, 如下图

02-钩子函数执行顺序.png

before_first_request

在对应用程序实例的第一个请求之前注册要运行的函数, 只会执行一次

#: A lists of functions that should be called at the beginning of the

#: first request to this instance. To register a function here, use

#: the :meth:`before_first_request` decorator.

#:

#: .. versionadded:: 0.8

self.before_first_request_funcs = []

@setupmethod

def before_first_request(self, f):

"""Registers a function to be run before the first request to this

instance of the application.

.. versionadded:: 0.8

"""

self.before_first_request_funcs.append(f)

将要运行的函数存放到before_first_request_funcs 属性中进行保存

before_request

在每个请求之前注册一个要运行的函数, 每一次请求都会执行

#: A dictionary with lists of functions that should be called at the

#: beginning of the request. The key of the dictionary is the name of

#: the blueprint this function is active for, `None` for all requests.

#: This can for example be used to open database connections or

#: getting hold of the currently logged in user. To register a

#: function here, use the :meth:`before_request` decorator.

self.before_request_funcs = {}

@setupmethod

def before_request(self, f):

"""Registers a function to run before each request."""

self.before_request_funcs.setdefault(None, []).append(f)

return f

将要运行的函数存放在字典中, None 为键的列表中存放的是整个应用的所有请求都要运行的函数.

after_request

在每个请求之后注册一个要运行的函数, 每次请求都会执行. 需要接收一个 Response 类的对象作为参数 并返回一个新的Response 对象 或者 直接返回接受到的Response 对象

#: A dictionary with lists of functions that should be called after

#: each request. The key of the dictionary is the name of the blueprint

#: this function is active for, `None` for all requests. This can for

#: example be used to open database connections or getting hold of the

#: currently logged in user. To register a function here, use the

#: :meth:`after_request` decorator.

self.after_request_funcs = {}

@setupmethod

def after_request(self, f):

"""Register a function to be run after each request. Your function

must take one parameter, a :attr:`response_class` object and return

a new response object or the same (see :meth:`process_response`).

As of Flask 0.7 this function might not be executed at the end of the

request in case an unhandled exception occurred.

"""

self.after_request_funcs.setdefault(None, []).append(f)

return f

将要运行的函数存放在字典中, None 为键的列表中存放的是整个应用的所有请求都要运行的函数.

teardown_request

注册一个函数在每个请求的末尾运行,不管是否有异常, 每次请求的最后都会执行.

#: A dictionary with lists of functions that are called after

#: each request, even if an exception has occurred. The key of the

#: dictionary is the name of the blueprint this function is active for,

#: `None` for all requests. These functions are not allowed to modify

#: the request, and their return values are ignored. If an exception

#: occurred while processing the request, it gets passed to each

#: teardown_request function. To register a function here, use the

#: :meth:`teardown_request` decorator.

#:

#: .. versionadded:: 0.7

self.teardown_request_funcs = {}

@setupmethod

def teardown_request(self, f):

"""Register a function to be run at the end of each request,

regardless of whether there was an exception or not. These functions

are executed when the request context is popped, even if not an

actual request was performed.

"""

self.teardown_request_funcs.setdefault(None, []).append(f)

return f

将要运行的函数存放在字典中, None 为键的列表中存放的是整个应用的所有请求都要运行的函数.

app.run

def run(self, host=None, port=None, debug=None, **options):

"""Runs the application on a local development server. If the

:attr:`debug` flag is set the server will automatically reload

for code changes and show a debugger in case an exception happened.

.. versionchanged:: 0.10

The default port is now picked from the ``SERVER_NAME`` variable.

:param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to

have the server available externally as well. Defaults to

``'127.0.0.1'``.

:param port: the port of the webserver. Defaults to ``5000`` or the

port defined in the ``SERVER_NAME`` config variable if

present.

:param debug: if given, enable or disable debug mode.

See :attr:`debug`.

:param options: the options to be forwarded to the underlying

Werkzeug server. See

:func:`werkzeug.serving.run_simple` for more

information.

"""

from werkzeug.serving import run_simple

# 主机地址 默认为'127.0.0.1'

if host is None:

host = '127.0.0.1'

# 端口 默认为5000

if port is None:

server_name = self.config['SERVER_NAME']

if server_name and ':' in server_name:

port = int(server_name.rsplit(':', 1)[1])

else:

port = 5000

# debug 默认为false

if debug is not None:

self.debug = bool(debug)

# 设置 use_reloader use_debugger

options.setdefault('use_reloader', self.debug)

options.setdefault('use_debugger', self.debug)

# 参数设置完成调用run_simple 启动服务

try:

run_simple(host, port, self, **options)

finally:

# reset the first request information if the development server

# resetted normally. This makes it possible to restart the server

# without reloader and that stuff from an interactive shell.

self._got_first_request = False

run_simple

def run_simple(hostname, port, application, use_reloader=False,

use_debugger=False, use_evalex=True,

extra_files=None, reloader_interval=1,

reloader_type='auto', threaded=False,

processes=1, request_handler=None, static_files=None,

passthrough_errors=False, ssl_context=None):

"""Start a WSGI application. Optional features include a reloader,

multithreading and fork support.

...( 省略 )...

"""

# 检查端口

if not isinstance(port, int):

raise TypeError('port must be an integer')

# 是否开启debug

if use_debugger:

from werkzeug.debug import DebuggedApplication

application = DebuggedApplication(application, use_evalex)

# 设置静态资源文件

if static_files:

from werkzeug.wsgi import SharedDataMiddleware

application = SharedDataMiddleware(application, static_files)

# ...(省略)...

DebuggedApplication

def __init__(self, app, evalex=False, request_key='werkzeug.request',

console_path='/console', console_init_func=None,

show_hidden_frames=False, lodgeit_url=None,

pin_security=True, pin_logging=True):

if lodgeit_url is not None:

from warnings import warn

warn(DeprecationWarning('Werkzeug now pastes into gists.'))

if not console_init_func:

console_init_func = None

self.app = app

self.evalex = evalex

self.frames = {}

self.tracebacks = {}

self.request_key = request_key

self.console_path = console_path

self.console_init_func = console_init_func

self.show_hidden_frames = show_hidden_frames

self.secret = gen_salt(20)

self._failed_pin_auth = 0

self.pin_logging = pin_logging

if pin_security:

# Print out the pin for the debugger on standard out.

if os.environ.get('WERKZEUG_RUN_MAIN') == 'true' and \

pin_logging:

_log('warning', ' * Debugger is active!')

if self.pin is None:

_log('warning', ' * Debugger PIN disabled. '

'DEBUGGER UNSECURED!')

else:

_log('info', ' * Debugger PIN: %s' % self.pin)

else:

self.pin = None

def debug_application(self, environ, start_response):

"""Run the application and conserve the traceback frames."""

app_iter = None

try:

app_iter = self.app(environ, start_response)

for item in app_iter:

yield item

if hasattr(app_iter, 'close'):

app_iter.close()

except Exception:

if hasattr(app_iter, 'close'):

app_iter.close()

traceback = get_current_traceback(

skip=1, show_hidden_frames=self.show_hidden_frames,

ignore_system_exceptions=True)

for frame in traceback.frames:

self.frames[frame.id] = frame

self.tracebacks[traceback.id] = traceback

try:

start_response('500 INTERNAL SERVER ERROR', [

('Content-Type', 'text/html; charset=utf-8'),

# Disable Chrome's XSS protection, the debug

# output can cause false-positives.

('X-XSS-Protection', '0'),

])

except Exception:

# if we end up here there has been output but an error

# occurred. in that situation we can do nothing fancy any

# more, better log something into the error log and fall

# back gracefully.

environ['wsgi.errors'].write(

'Debugging middleware caught exception in streamed '

'response at a point where response headers were already '

'sent.\n')

else:

is_trusted = bool(self.check_pin_trust(environ))

yield traceback.render_full(evalex=self.evalex,

evalex_trusted=is_trusted,

secret=self.secret) \

.encode('utf-8', 'replace')

traceback.log(environ['wsgi.errors'])

通过app.run 可以得知 run_simple 方法将Flask 类的实例对象作为实参传递给DebuggedApplication 类,初始化了一个DebuggedApplication 类的实例对象对象application. 结合debug_application 的描述可以得知, debug_application方法会被调用 ( WSGIRequestHandler 类 run_wsgi 方法 的内部方法 execute ).

app_iter = self.app(environ, start_response), self是DebuggedApplication 类的实例对象的引用, app 从__init__ 魔法方法得知是Flask 类的实例对象, 所以app(environ, start_response) 会调用Flask 类的魔法方法__call__

Flask 类的__call__ 魔法方法

def __call__(self, environ, start_response):

"""Shortcut for :attr:`wsgi_app`."""

return self.wsgi_app(environ, start_response)

def wsgi_app(self, environ, start_response):

"""The actual WSGI application. This is not implemented in

`__call__` so that middlewares can be applied without losing a

reference to the class. So instead of doing this::

app = MyMiddleware(app)

It's a better idea to do this instead::

app.wsgi_app = MyMiddleware(app.wsgi_app)

Then you still have the original application object around and

can continue to call methods on it.

.. versionchanged:: 0.7

The behavior of the before and after request callbacks was changed

under error conditions and a new callback was added that will

always execute at the end of the request, independent on if an

error occurred or not. See :ref:`callbacks-and-errors`.

:param environ: a WSGI environment

:param start_response: a callable accepting a status code,

a list of headers and an optional

exception context to start the response

"""

ctx = self.request_context(environ)

ctx.push()

error = None

try:

try:

response = self.full_dispatch_request()

except Exception as e:

error = e

response = self.make_response(self.handle_exception(e))

return response(environ, start_response)

finally:

if self.should_ignore_error(error):

error = None

ctx.auto_pop(error)

full_dispatch_request

def full_dispatch_request(self):

"""Dispatches the request and on top of that performs request

pre and postprocessing as well as HTTP exception catching and

error handling.

.. versionadded:: 0.7

"""

self.try_trigger_before_first_request_functions()

try:

request_started.send(self)

rv = self.preprocess_request()

if rv is None:

rv = self.dispatch_request()

except Exception as e:

rv = self.handle_user_exception(e)

response = self.make_response(rv)

response = self.process_response(response)

request_finished.send(self, response=response)

return response

@property

def got_first_request(self):

"""This attribute is set to `True` if the application started

handling the first request.

.. versionadded:: 0.8

"""

return self._got_first_request

def try_trigger_before_first_request_functions(self):

"""Called before each request and will ensure that it triggers

the :attr:`before_first_request_funcs` and only exactly once per

application instance (which means process usually).

:internal:

"""

if self._got_first_request:

return

with self._before_request_lock:

if self._got_first_request:

return

self._got_first_request = True

for func in self.before_first_request_funcs:

func()

def preprocess_request(self):

"""Called before the actual request dispatching and will

call every as :meth:`before_request` decorated function.

If any of these function returns a value it's handled as

if it was the return value from the view and further

request handling is stopped.

This also triggers the :meth:`url_value_processor` functions before

the actual :meth:`before_request` functions are called.

"""

bp = _request_ctx_stack.top.request.blueprint

funcs = self.url_value_preprocessors.get(None, ())

if bp is not None and bp in self.url_value_preprocessors:

funcs = chain(funcs, self.url_value_preprocessors[bp])

for func in funcs:

func(request.endpoint, request.view_args)

funcs = self.before_request_funcs.get(None, ())

if bp is not None and bp in self.before_request_funcs:

funcs = chain(funcs, self.before_request_funcs[bp])

for func in funcs:

rv = func()

if rv is not None:

return rv

def dispatch_request(self):

"""Does the request dispatching. Matches the URL and returns the

return value of the view or error handler. This does not have to

be a response object. In order to convert the return value to a

proper response object, call :func:`make_response`.

.. versionchanged:: 0.7

This no longer does the exception handling, this code was

moved to the new :meth:`full_dispatch_request`.

"""

req = _request_ctx_stack.top.request

if req.routing_exception is not None:

self.raise_routing_exception(req)

rule = req.url_rule

# if we provide automatic options for this URL and the

# request came with the OPTIONS method, reply automatically

if getattr(rule, 'provide_automatic_options', False) \

and req.method == 'OPTIONS':

return self.make_default_options_response()

# otherwise dispatch to the handler for that endpoint

return self.view_functions[rule.endpoint](**req.view_args)

def process_response(self, response):

"""Can be overridden in order to modify the response object

before it's sent to the WSGI server. By default this will

call all the :meth:`after_request` decorated functions.

.. versionchanged:: 0.5

As of Flask 0.5 the functions registered for after request

execution are called in reverse order of registration.

:param response: a :attr:`response_class` object.

:return: a new response object or the same, has to be an

instance of :attr:`response_class`.

"""

ctx = _request_ctx_stack.top

bp = ctx.request.blueprint

funcs = ctx._after_request_functions

if bp is not None and bp in self.after_request_funcs:

funcs = chain(funcs, reversed(self.after_request_funcs[bp]))

if None in self.after_request_funcs:

funcs = chain(funcs, reversed(self.after_request_funcs[None]))

for handler in funcs:

response = handler(response)

if not self.session_interface.is_null_session(ctx.session):

self.save_session(ctx.session, response)

return response

通过 full_dispatch_request 方法可以知道,

try_trigger_before_first_request_functions 方法通过判断 _got_first_request 属性, 决定是不是要执行before_first_request_funcs 列表( 钩子函数before_first_request ) 的方法

调用preprocess_request 方法, < self.before_request_funcs.get(None, ()) > 从before_request_funcs 字典( 钩子函数 before_request ) 得到键为None的方法列表

调用dispatch_request 根据路由规则调用指定的视图函数

调用process_response 方法,

# 从after_request_funcs 字典( 钩子函数 after_request ) 得到键为None的方法列表

if None in self.after_request_funcs:

funcs = chain(funcs, reversed(self.after_request_funcs[None]))

# 遍历,执行,并且将response 对象作为实参进行传递

for handler in funcs:

response = handler(response)

ctx.auto_pop(error)

# wsgi_app 方法的部分代码, Flask 类的request_context 方法

ctx = self.request_context(environ)

ctx.auto_pop(error)

# ctx 是RequestContext 类的实例对象, Flask 类的request_context 方法

def request_context(self, environ):

return RequestContext(self, environ)

# RequestContext 类的__init__魔法方法,

# app形参接收的是Flask 类的实例对象赋值给RequestContext 类的属性self.app

def __init__(self, app, environ, request=None):

def auto_pop(self, exc):

if self.request.environ.get('flask._preserve_context') or \

(exc is not None and self.app.preserve_context_on_exception):

self.preserved = True

self._preserved_exc = exc

else:

self.pop(exc)

def pop(self, exc=None):

"""Pops the request context and unbinds it by doing that. This will

also trigger the execution of functions registered by the

:meth:`~flask.Flask.teardown_request` decorator.

.. versionchanged:: 0.9

Added the `exc` argument.

"""

app_ctx = self._implicit_app_ctx_stack.pop()

clear_request = False

if not self._implicit_app_ctx_stack:

self.preserved = False

self._preserved_exc = None

if exc is None:

exc = sys.exc_info()[1]

self.app.do_teardown_request(exc)

# If this interpreter supports clearing the exception information

# we do that now. This will only go into effect on Python 2.x,

# on 3.x it disappears automatically at the end of the exception

# stack.

if hasattr(sys, 'exc_clear'):

sys.exc_clear()

request_close = getattr(self.request, 'close', None)

if request_close is not None:

request_close()

clear_request = True

# ...(省略)...

结合wsgi_app 方法,可以得知无论是否出错RequestContext 类的auto_pop 都会被调用. auto_pop 调用了self.pop, self.pop 通过判断调用了self.app.do_teardown_request(exc) , 既调用了Flask 类的do_teardown_request 方法

do_teardown_request

def do_teardown_request(self, exc=None):

"""Called after the actual request dispatching and will

call every as :meth:`teardown_request` decorated function. This is

not actually called by the :class:`Flask` object itself but is always

triggered when the request context is popped. That way we have a

tighter control over certain resources under testing environments.

.. versionchanged:: 0.9

Added the `exc` argument. Previously this was always using the

current exception information.

"""

if exc is None:

exc = sys.exc_info()[1]

funcs = reversed(self.teardown_request_funcs.get(None, ()))

bp = _request_ctx_stack.top.request.blueprint

if bp is not None and bp in self.teardown_request_funcs:

funcs = chain(funcs, reversed(self.teardown_request_funcs[bp]))

for func in funcs:

rv = func(exc)

request_tearing_down.send(self, exc=exc)

do_teardown_request 方法, 从 < self.teardown_request_funcs > 字典 ( 钩子函数 teardown_request ) 中得到方法列表( self.teardown_request_funcs.get(None, ()) ), 遍历,执行,并且传递一个Exception 类的实例对象exc

小结

对于应用来说有四个钩子函数

before_first_request

before_request

after_request

teardown_request

钩子函数扮演了工人的角色, 将通过装饰器装饰的函数存储到指定的容器( 字典或者列表 ), 程序在处理请求的过程中会直接对容器进行操作, 而不会对钩子函数进行调用.

Blueprint 钩子函数

E:\workspace\pycharm\Demo\modules_init_.py

from flask import Blueprint

blue_index = Blueprint("index", __name__)

blue_user = Blueprint("user", __name__, url_prefix="/user")

blue_admin = Blueprint("admin", __name__, url_prefix="/admin")

from . import views_index

from . import views_user

from . import views_admin

@blue_index.before_app_first_request

def before_app_first():

print("before_app_first")

@blue_index.before_app_request

def before_app():

print("before_app")

@blue_index.before_request

def before():

print("before")

@blue_index.after_app_request

def after_app(response):

print("after_app")

return response

@blue_index.after_request

def after(response):

print("after")

return response

@blue_admin.teardown_app_request

def teardown_app(e):

print("teardown_app")

@blue_admin.teardown_request

def teardown(e):

print("teardown")

运行结果

before_app_first

before_app

before

after

after_app

teardown_app

teardown

从结果上来看,七个钩子都被执行了.

根据Blueprint 钩子函数的运行结果以及前面对应用的钩子函数的理解,

推测1 : Blueprint 钩子函数其内部应该也是对某一个容器进行更改,

推测2 : 按照打印顺序可以得出另一个推测, 如下图, 蓝图的请求钩子是在应用的请求钩子的基础上增加了自己的钩子,共同构成了蓝图的七个请求钩子.

03-蓝图的请求钩子.png

before_app_first_request

def before_app_first_request(self, f):

"""Like :meth:`Flask.before_first_request`. Such a function is

executed before the first request to the application.

"""

# app.before_first_request_funcs

self.record_once(lambda s: s.app.before_first_request_funcs.append(f))

return f

before_app_request

def before_app_request(self, f):

"""Like :meth:`Flask.before_request`. Such a function is executed

before each request, even if outside of a blueprint.

"""

# app.before_request_funcs

self.record_once(lambda s: s.app.before_request_funcs

.setdefault(None, []).append(f))

return f

before_request

def before_request(self, f):

"""Like :meth:`Flask.before_request` but for a blueprint. This function

is only executed before each request that is handled by a function of

that blueprint.

"""

# app.before_request_funcs

self.record_once(lambda s: s.app.before_request_funcs

.setdefault(self.name, []).append(f))

return f

after_app_request

def after_app_request(self, f):

"""Like :meth:`Flask.after_request` but for a blueprint. Such a function

is executed after each request, even if outside of the blueprint.

"""

# app.after_request_funcs

self.record_once(lambda s: s.app.after_request_funcs

.setdefault(None, []).append(f))

return f

after_request

def after_request(self, f):

"""Like :meth:`Flask.after_request` but for a blueprint. This function

is only executed after each request that is handled by a function of

that blueprint.

"""

# app.after_request_funcs

self.record_once(lambda s: s.app.after_request_funcs

.setdefault(self.name, []).append(f))

return f

teardown_app_request

def teardown_app_request(self, f):

"""Like :meth:`Flask.teardown_request` but for a blueprint. Such a

function is executed when tearing down each request, even if outside of

the blueprint.

"""

# app.teardown_request_funcs

self.record_once(lambda s: s.app.teardown_request_funcs

.setdefault(None, []).append(f))

return f

teardown_request

def teardown_request(self, f):

"""Like :meth:`Flask.teardown_request` but for a blueprint. This

function is only executed when tearing down requests handled by a

function of that blueprint. Teardown request functions are executed

when the request context is popped, even when no actual request was

performed.

"""

# app.teardown_request_funcs

self.record_once(lambda s: s.app.teardown_request_funcs

.setdefault(self.name, []).append(f))

return f

从上面可以看出蓝图的钩子函数和应用的钩子函数一样都是在操作相同容器, 证明我们的推测1 是正确的. 既然都是在修改相同的容器, 结合在分析应用钩子函数的时候我们知道了wsgi_app 中和钩子函数有关的两个方法full_dispatch_request 和 ctx.auto_pop(error) , 所以接下来就分析这两个方法.

full_dispatch_request

def full_dispatch_request(self):

"""Dispatches the request and on top of that performs request

pre and postprocessing as well as HTTP exception catching and

error handling.

.. versionadded:: 0.7

"""

self.try_trigger_before_first_request_functions()

try:

request_started.send(self)

rv = self.preprocess_request()

if rv is None:

rv = self.dispatch_request()

except Exception as e:

rv = self.handle_user_exception(e)

response = self.make_response(rv)

response = self.process_response(response)

request_finished.send(self, response=response)

return response

从full_dispatch_request 中得到和钩子函数有关的函数,按照顺序分别是try_trigger_before_first_request_functions --> preprocess_request --> dispatch_request --> process_response,

app.before_first_request 和 blue.before_app_first_request

**try_trigger_before_first_request_functions **

def try_trigger_before_first_request_functions(self):

"""Called before each request and will ensure that it triggers

the :attr:`before_first_request_funcs` and only exactly once per

application instance (which means process usually).

:internal:

"""

if self._got_first_request:

return

with self._before_request_lock:

if self._got_first_request:

return

self._got_first_request = True

for func in self.before_first_request_funcs:

func()

app.before_first_request

def before_first_request(self, f):

"""Registers a function to be run before the first request to this

instance of the application.

.. versionadded:: 0.8

"""

self.before_first_request_funcs.append(f)

blue.before_app_first_request

def before_app_first_request(self, f):

"""Like :meth:`Flask.before_first_request`. Such a function is

executed before the first request to the application.

"""

self.record_once(lambda s: s.app.before_first_request_funcs.append(f))

return f

从上面的三个方法可以看出app.before_first_request 和 blue.before_app_first_request 都是将func 存储到before_first_request_funcs 列表中,并且通过try_trigger_before_first_request_functions 方法可以得知app 和blue 同等对待,并没有区别.

app.before_request / blue.before_app_request / blue.before_request

**preprocess_request **

def preprocess_request(self):

"""Called before the actual request dispatching and will

call every as :meth:`before_request` decorated function.

If any of these function returns a value it's handled as

if it was the return value from the view and further

request handling is stopped.

This also triggers the :meth:`url_value_processor` functions before

the actual :meth:`before_request` functions are called.

"""

bp = _request_ctx_stack.top.request.blueprint

funcs = self.url_value_preprocessors.get(None, ())

if bp is not None and bp in self.url_value_preprocessors:

funcs = chain(funcs, self.url_value_preprocessors[bp])

for func in funcs:

func(request.endpoint, request.view_args)

funcs = self.before_request_funcs.get(None, ())

if bp is not None and bp in self.before_request_funcs:

funcs = chain(funcs, self.before_request_funcs[bp])

for func in funcs:

rv = func()

if rv is not None:

return rv

app.before_request

def before_request(self, f):

"""Registers a function to run before each request."""

self.before_request_funcs.setdefault(None, []).append(f)

return f

blue.before_app_request

def before_app_request(self, f):

"""Like :meth:`Flask.before_request`. Such a function is executed

before each request, even if outside of a blueprint.

"""

self.record_once(lambda s: s.app.before_request_funcs

.setdefault(None, []).append(f))

return f

blue.before_request

def before_request(self, f):

"""Like :meth:`Flask.before_request` but for a blueprint. This function

is only executed before each request that is handled by a function of

that blueprint.

"""

self.record_once(lambda s: s.app.before_request_funcs

.setdefault(self.name, []).append(f))

return f

虽然app.before_request / blue.before_app_request / blue.before_request都是将方法存储到before_request_funcs 字典中, 但是blue.before_request 是将方法存储到以self.name( 蓝图名 ) 为键的列表中.

preprocess_request 方法, 先得到None 为键的函数列表( funcs = self.before_request_funcs.get(None, ()) ), 然后判断蓝图 ( if bp is not None and bp in self.before_request_funcs ) , 遍历并调用方法.

test1

from itertools import chain

c = chain([1, 2, 3], [4, 5, 6])

for i in c:

print(i)

# 运行结果

# 1

# 2

# 3

# 4

# 5

# 6

结合前面的运行结果可以得出,虽然chain 看不到源码,但是结合test1 的运行结果可以得知chain 的作用是将两个列表进行了链接, 因为以None 为键的函数列表在前,所以会先被调用执行, 以蓝图名为键的函数列表被链接到后面,所以后被调用. 所以运行结果表现为先打印before_app 后打印before .

preprocess_request 执行完成会调用视图函数, 不对视图函数部分做研究

blue.after_request / blue.after_app_request / app.after_request

process_response

def process_response(self, response):

"""Can be overridden in order to modify the response object

before it's sent to the WSGI server. By default this will

call all the :meth:`after_request` decorated functions.

.. versionchanged:: 0.5

As of Flask 0.5 the functions registered for after request

execution are called in reverse order of registration.

:param response: a :attr:`response_class` object.

:return: a new response object or the same, has to be an

instance of :attr:`response_class`.

"""

ctx = _request_ctx_stack.top

bp = ctx.request.blueprint

funcs = ctx._after_request_functions

if bp is not None and bp in self.after_request_funcs:

funcs = chain(funcs, reversed(self.after_request_funcs[bp]))

if None in self.after_request_funcs:

funcs = chain(funcs, reversed(self.after_request_funcs[None]))

for handler in funcs:

response = handler(response)

if not self.session_interface.is_null_session(ctx.session):

self.save_session(ctx.session, response)

return response

blue.after_request

def after_request(self, f):

"""Like :meth:`Flask.after_request` but for a blueprint. This function

is only executed after each request that is handled by a function of

that blueprint.

"""

self.record_once(lambda s: s.app.after_request_funcs

.setdefault(self.name, []).append(f))

return f

blue.after_app_request

def after_app_request(self, f):

"""Like :meth:`Flask.after_request` but for a blueprint. Such a function

is executed after each request, even if outside of the blueprint.

"""

self.record_once(lambda s: s.app.after_request_funcs

.setdefault(None, []).append(f))

return f

app.after_request

def after_request(self, f):

"""Register a function to be run after each request. Your function

must take one parameter, a :attr:`response_class` object and return

a new response object or the same (see :meth:`process_response`).

As of Flask 0.7 this function might not be executed at the end of the

request in case an unhandled exception occurred.

"""

self.after_request_funcs.setdefault(None, []).append(f)

return f

blue.after_request / blue.after_app_request / app.after_request 都是将方法存储到after_request_funcs 字典中, 但是blue.after_request是将方法存储到以self.name( 蓝图名 ) 为键的列表中.

process_response 方法, 先判断蓝图名然后使用chain 链接以蓝图名为键的函数列表, 然后判断链接以None 为键的函数列表. 所以会先打印after_request 再打印after_app_request

app.teardown_request / blue.teardown_app_request / blue.teardown_request

ctx.auto_pop(error) 和钩子函数有关的主要部分是Flask 类的do_teardown_request 方法, 所以着重探究do_teardown_request 方法

do_teardown_request

def do_teardown_request(self, exc=None):

"""Called after the actual request dispatching and will

call every as :meth:`teardown_request` decorated function. This is

not actually called by the :class:`Flask` object itself but is always

triggered when the request context is popped. That way we have a

tighter control over certain resources under testing environments.

.. versionchanged:: 0.9

Added the `exc` argument. Previously this was always using the

current exception information.

"""

if exc is None:

exc = sys.exc_info()[1]

funcs = reversed(self.teardown_request_funcs.get(None, ()))

bp = _request_ctx_stack.top.request.blueprint

if bp is not None and bp in self.teardown_request_funcs:

funcs = chain(funcs, reversed(self.teardown_request_funcs[bp]))

for func in funcs:

rv = func(exc)

request_tearing_down.send(self, exc=exc)

blue.teardown_app_request

def teardown_app_request(self, f):

"""Like :meth:`Flask.teardown_request` but for a blueprint. Such a

function is executed when tearing down each request, even if outside of

the blueprint.

"""

self.record_once(lambda s: s.app.teardown_request_funcs

.setdefault(None, []).append(f))

return f

blue.teardown_request

def teardown_request(self, f):

"""Like :meth:`Flask.teardown_request` but for a blueprint. This

function is only executed when tearing down requests handled by a

function of that blueprint. Teardown request functions are executed

when the request context is popped, even when no actual request was

performed.

"""

self.record_once(lambda s: s.app.teardown_request_funcs

.setdefault(self.name, []).append(f))

return f

app.teardown_request

def teardown_request(self, f):

"""Register a function to be run at the end of each request,

regardless of whether there was an exception or not. These functions

are executed when the request context is popped, even if not an

actual request was performed.

Example::

ctx = app.test_request_context()

ctx.push()

...

ctx.pop()

When ``ctx.pop()`` is executed in the above example, the teardown

functions are called just before the request context moves from the

stack of active contexts. This becomes relevant if you are using

such constructs in tests.

Generally teardown functions must take every necessary step to avoid

that they will fail. If they do execute code that might fail they

will have to surround the execution of these code by try/except

statements and log occurring errors.

When a teardown function was called because of a exception it will

be passed an error object.

.. admonition:: Debug Note

In debug mode Flask will not tear down a request on an exception

immediately. Instead if will keep it alive so that the interactive

debugger can still access it. This behavior can be controlled

by the ``PRESERVE_CONTEXT_ON_EXCEPTION`` configuration variable.

"""

self.teardown_request_funcs.setdefault(None, []).append(f)

return f

app.teardown_request/ blue.teardown_app_request/ blue.teardown_request 都是将方法存储到after_request_funcs 字典中, 但是blue.teardown_request 是将方法存储到以self.name( 蓝图名 ) 为键的列表中.

do_teardown_request 方法, 先得到以None 为键的函数列表, 然后通过chain 链接以蓝图名 为键的函数列表. 所以会先打印after_app_request 再打印after_request

经过以上探究可以证明推测2 是正确的. 这个顺序可以理解为请求两部分应用部分 和蓝图部分. 当请求需要进入蓝图时, 先要通过应用部分的认证, 才能访问蓝图部分, 访问完蓝图之后, 要先从蓝图出来, 再经过应用返回响应. 如果出错, 先检查应用是否有错, 如果应用出错, 则返回, 否则返回蓝图的错误.

这个过程有点像你去拜访朋友, 要现在门卫登记, 然后经过允许才能进入小区, 到达朋友家门前. 敲门, 朋友给你开门才正式进入朋友家. 拜访结束你要从朋友家出来 ( 是走出来 ) , 要先出朋友的家门, 到达门卫, 然后出小区,回家. 如果你发现丢了东西, 要先问问门卫有没捡到失物, 如果有你就不用上楼找朋友了. 如果没有你就需要上楼问一问朋友了.

总结

钩子函数分为应用钩子函数 以及蓝图钩子函数

应用钩子函数 4个

app.before_first_request

app.before_request

app.after_request

app.teardown_request

蓝图钩子函数 7个

blue.before_app_first_request

blue.before_app_request

blue.before_request

blue.after_request

blue.after_app_request

blue.teardown_app_request

blue.teardown_request

在不发生错误的前提下, blue.before_app_first_request / blue.before_app_request / blue.before_request / blue.after_request / blue.after_app_request 都可以返回响应

到此结  DragonFangQy 2018.7.8

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值