Flask源码解读--所有可扩展点

pip3 install blinker

request_started = _signals.signal('request-started')                # 请求到来前执行
request_finished = _signals.signal('request-finished')              # 请求结束后执行
 
before_render_template = _signals.signal('before-render-template')  # 模板渲染前执行
template_rendered = _signals.signal('template-rendered')            # 模板渲染后执行
 
got_request_exception = _signals.signal('got-request-exception')    # 请求执行出现异常时执行
 
request_tearing_down = _signals.signal('request-tearing-down')      # 请求执行完毕后自动执行（无论成功与否）
appcontext_tearing_down = _signals.signal('appcontext-tearing-down')# 应用上下文执行完毕后自动执行（无论成功与否）
 
appcontext_pushed = _signals.signal('appcontext-pushed')            # 应用上下文push时执行
appcontext_popped = _signals.signal('appcontext-popped')            # 应用上下文pop时执行
message_flashed = _signals.signal('message-flashed')                # 调用消息闪现时，自动触发

from flask import Flask, signals, request

app = Flask(import_name=__name__)


def check_host(app, *args):
    print(app.config['DEBUG'])
    print("host is :", request.host)


signals.request_started.connect(receiver=check_host)  # 请求之前发送信号检查请求的host


@app.route("/")
def index():
    return 'index'


if __name__ == '__main__':
    app.run()

#结果
False
host is : 127.0.0.1:5000

from flask import Flask, signals, request

app = Flask(import_name=__name__)

@signals.request_started.connect_via(app)
def check_host(app, *args):
    print(app.config['DEBUG'])
    print("host is :", request.host)


@app.route("/")
def index():
    return 'index'


if __name__ == '__main__':
    app.run()

rom flask import Flask
from blinker import Namespace

app = Flask(import_name=__name__)
model_signals=Namespace()

# 定义信号

model_update = model_signals.signal(name='model_update')


#触发信号是对应的操作
def logging(arg):
    print(arg)
    print('write log..')


#订阅信号
model_update.connect(logging)


@app.route("/")
def index():
    # 触发信号
    model_update.send('save model')
    return 'index'


if __name__ == '__main__':
    app.run()
结果：
save model
write log..

def wsgi_app(self, environ, start_response):
    """The actual WSGI application. This is not implemented in
    :meth:`__call__` so that middlewares can be applied without
    losing a reference to the app object. 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
        Teardown events for the request and app contexts are called
        even if an unhandled error occurs. Other events may not be
        called depending on when an error occurs during dispatch.
        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)
    error = None
    try:
        try:
            ctx.push() #存储请求上下文
            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) #删除栈中的请求上下文

def push(self):
    """Binds the app context to the current context."""
    self._refcnt += 1
    if hasattr(sys, 'exc_clear'):
        sys.exc_clear()
    _app_ctx_stack.push(self)
    appcontext_pushed.send(self.app) #触发appcontext_pushed信号

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() #执行请求扩展before_first_request
    try:
        request_started.send(self)  #触发request_started信号
        rv = self.preprocess_request()
        if rv is None:
            rv = self.dispatch_request()
    except Exception as e:
        rv = self.handle_user_exception(e)  #处理异常
    return self.finalize_request(rv)  #最后对请求进行最后的处理 

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, ()) #执行请求扩展before_request
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 _render(template, context, app):
    """Renders the template and fires the signal"""

    before_render_template.send(app, template=template, context=context) # 触发before_render_template信号
    rv = template.render(context)   # 模版渲染
    template_rendered.send(app, template=template, context=context) ## 触发template_rendered信号
    return rv

def finalize_request(self, rv, from_error_handler=False):
    """Given the return value from a view function this finalizes
    the request by converting it into a response and invoking the
    postprocessing functions.  This is invoked for both normal
    request dispatching as well as error handlers.

    Because this means that it might be called as a result of a
    failure a special safe mode is available which can be enabled
    with the `from_error_handler` flag.  If enabled, failures in
    response processing will be logged and otherwise ignored.

    :internal:
    """
    response = self.make_response(rv)
    try:
        response = self.process_response(response)   #处理响应
        request_finished.send(self, response=response) # 触发request_finished信号
    except Exception:
        if not from_error_handler:
            raise
        self.logger.exception('Request finalizing failed with an '
                              'error while handling an error')
    return 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]))#执行请求扩张after_request
    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.session_interface.save_session(self, ctx.session, response)  # 保存session
    return response

def handle_exception(self, e):
    """Default exception handling that kicks in when an exception
    occurs that is not caught.  In debug mode the exception will
    be re-raised immediately, otherwise it is logged and the handler
    for a 500 internal server error is used.  If no such handler
    exists, a default 500 internal server error message is displayed.

    .. versionadded:: 0.3
    """
    exc_type, exc_value, tb = sys.exc_info()

    got_request_exception.send(self, exception=e) #触发got_request_exception信号
    handler = self._find_error_handler(InternalServerError())

    if self.propagate_exceptions:
        # if we want to repropagate the exception, we can attempt to
        # raise it with the whole traceback in case we can do that
        # (the function was actually called from the except part)
        # otherwise, we just raise the error again
        if exc_value is e:
            reraise(exc_type, exc_value, tb)
        else:
            raise e

    self.log_exception((exc_type, exc_value, tb))
    if handler is None:
        return InternalServerError()
    return self.finalize_request(handler(e), from_error_handler=True)

def pop(self, exc=_sentinel):
    """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()

    try:
        clear_request = False
        if not self._implicit_app_ctx_stack:
            self.preserved = False
            self._preserved_exc = None
            if exc is _sentinel:
                exc = sys.exc_info()[1]
            self.app.do_teardown_request(exc) # 触发request_tearing_down信号

            # 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
    finally:
        rv = _request_ctx_stack.pop()

        # get rid of circular dependencies at the end of the request
        # so that we don't require the GC to be active.
        if clear_request:
            rv.request.environ['werkzeug.request'] = None

        # Get rid of the app as well if necessary.
        if app_ctx is not None:
            app_ctx.pop(exc)  #触发teardown_appcontext信号

        assert rv is self, 'Popped wrong request context.  ' \
            '(%r instead of %r)' % (rv, self)

def pop(self, exc=_sentinel):
    """Pops the app context."""
    try:
        self._refcnt -= 1
        if self._refcnt <= 0:
            if exc is _sentinel:
                exc = sys.exc_info()[1]
            self.app.do_teardown_appcontext(exc) #触发teardown_appcontext信号
    finally:
        rv = _app_ctx_stack.pop()
    assert rv is self, 'Popped wrong app context.  (%r instead of %r)' \
        % (rv, self)
    appcontext_popped.send(self.app) # 触发appcontext_poped信号