Flask的处理流程

1、简单Flask程序

from flask import Flask

app = Flask(__name__)


@app.route('/')
def hello_world():
    return 'Hello World!'


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

2、Flask运行流程

2.1、实例化Flask类生产app对象

from flask import Flask

app = Flask(__name__)

2.2、注册url，路由，endpoint到内存中

@app.route('/')
def hello_world():
    return 'Hello World!'

2.2.1、class Flask(_PackageBoundObject) 类中route()方法

def route(self, rule, **options):
    def decorator(f):
        endpoint = options.pop('endpoint', None)
        self.add_url_rule(rule, endpoint, f, **options)
        return f
    return decorator

2.2.2、class Flask(_PackageBoundObject) 类中add_url_rule()方法

def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
    if endpoint is None:
        endpoint = _endpoint_from_view_func(view_func)
    options['endpoint'] = endpoint
    methods = options.pop('methods', None)

    # if the methods are not given and the view_func object knows its
    # methods we can use that instead.  If neither exists, we go with
    # a tuple of only ``GET`` as default.
    if methods is None:
        methods = getattr(view_func, 'methods', None) or ('GET',)
    if isinstance(methods, string_types):
        raise TypeError('Allowed methods have to be iterables of strings, '
                        'for example: @app.route(..., methods=["POST"])')
    methods = set(item.upper() for item in methods)

    # Methods that should always be added
    required_methods = set(getattr(view_func, 'required_methods', ()))

    # starting with Flask 0.8 the view_func object can disable and
    # force-enable the automatic options handling.
    provide_automatic_options = getattr(view_func,
        'provide_automatic_options', None)

    if provide_automatic_options is None:
        if 'OPTIONS' not in methods:
            provide_automatic_options = True
            required_methods.add('OPTIONS')
        else:
            provide_automatic_options = False

    # Add the required methods now.
    methods |= required_methods

    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.get(endpoint)
        if old_func is not None and old_func != view_func:
            raise AssertionError('View function mapping is overwriting an '
                                 'existing endpoint function: %s' % endpoint)
        self.view_functions[endpoint] = view_func

　　执行完之后，将url放入app.url_map中；将视图函数放入app.view_functions中：

2.3、运行app.run()，检测客户端请求，并作出响应

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

2.3.1、执行Flask类中的run()方法

def run(self, host=None, port=None, debug=None, **options):
    from werkzeug.serving import run_simple
    if host is None:
        host = '127.0.0.1'
    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
    if debug is not None:
        self.debug = bool(debug)
    options.setdefault('use_reloader', self.debug)
    options.setdefault('use_debugger', self.debug)
    try:
        run_simple(host, port, self, **options)
    finally:
        # reset the first request information if the development server
        # reset normally.  This makes it possible to restart the server
        # without reloader and that stuff from an interactive shell.
        self._got_first_request = False

　　try之前的代码都是配置host、port、debug等参数。try中调用wsgi工具包werkzeug中的runsimple函数，用来建立socket链接，监听客户端数据，并进行解析处理，然后通过路由匹配找到视图函数，将数据交给视图处理后，再进行打包发给客户端。最后一行代码是将app中的_got_first_request标志置为False。当第一次客户端请求到来时置位True，用来触发before_first_request装饰器（第一次请求来在视图函数前面执行的代码）的运行。

2.3.2、请求来的时候执行流程

　　请求来的时候执行run_simple(host, port, self, **options)中的第三个参数，即self()，self就是app，因此执行Flask类中__call__方法。

　　Flask类中__call__方法：

def __call__(self, environ, start_response):
    """Shortcut for :attr:`wsgi_app`."""
    return self.wsgi_app(environ, start_response)

 2.3.3、wsgi_app中的environ,start_response

from werkzeug.wrappers import Response
from werkzeug.serving import run_simple


def run_server(environ, start_response):
    print("environ:",environ)
    print("type environ:",type(environ))
    print("start_response:", start_response)
    print("type start_response:", type(start_response))
    response = Response('hello')
    return response(environ, start_response)

if __name__ == '__main__':
    run_simple('127.0.0.1', 8000, run_server)

　　environ的类型是：<class 'dict'>，即字典类型

　　environ的内容如下：

environ: {
    'wsgi.version': (1, 0),
    'wsgi.url_scheme': 'http',
    'wsgi.input': < _io.BufferedReader name = 736 > ,
    'wsgi.errors': < _io.TextIOWrapper name = '<stderr>'
    mode = 'w'
    encoding = 'UTF-8' > ,
    'wsgi.multithread': False,
    'wsgi.multiprocess': False,
    'wsgi.run_once': False,
    'werkzeug.server.shutdown': < function WSGIRequestHandler.make_environ. < locals > .shutdown_server at 0x0000000012E1B510 > ,
    'SERVER_SOFTWARE': 'Werkzeug/0.14.1',
    'REQUEST_METHOD': 'POST',
    'SCRIPT_NAME': '',
    'PATH_INFO': '/',
    'QUERY_STRING': '',
    'REMOTE_ADDR': '127.0.0.1',
    'REMOTE_PORT': 11556,
    'SERVER_NAME': '127.0.0.1',
    'SERVER_PORT': '8000',
    'SERVER_PROTOCOL': 'HTTP/1.1',
    'CONTENT_TYPE': 'application/json',
    'HTTP_CACHE_CONTROL': 'no-cache',
    'HTTP_POSTMAN_TOKEN': 'fc8d2fdf-23c6-4461-9177-9c3965f09932',
    'HTTP_USER_AGENT': 'PostmanRuntime/7.3.0',
    'HTTP_ACCEPT': '*/*',
    'HTTP_HOST': '127.0.0.1:8000',
    'HTTP_ACCEPT_ENCODING': 'gzip, deflate',
    'CONTENT_LENGTH': '0',
    'HTTP_CONNECTION': 'keep-alive'
}

 　　start_response的类型是：<class 'function'>，即函数类型

　　 start_response的内容：

start_response: <function WSGIRequestHandler.run_wsgi.<locals>.start_response at 0x0000000012E2C510>

2.4、Flask类中的wsgi_app()方法

def wsgi_app(self, environ, start_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.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)

 2.5、Flask类中的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
    """
    
    # 处理第一次请求前的装饰器before_first_requst函数
    self.try_trigger_before_first_request_functions()
    try:
        request_started.send(self)
        rv = self.preprocess_request()
        
        # 如果before_request函数们处理返回的值为None，则进行正式处理
        if rv is None:
            rv = self.dispatch_request()
    except Exception as e:
        rv = self.handle_user_exception(e)
        
    # 使用after_response装饰器函数对视图函数执行后的结果进行处理
    return self.finalize_request(rv)

2.5.1、Flask类中的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.before_first_request_funcs = [],列表中存放函数
        for func in self.before_first_request_funcs:
            func()
        self._got_first_request = True

 2.5.2、Flask类中的preprocess_request()方法

def preprocess_request(self):
    """Called before the actual request dispatching and will
    call each :meth:`before_request` decorated function, passing no
    arguments.
    If any of these functions 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_preprocessor` 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)


        # 获取before_requesth装饰器函数并处理
    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

2.5.3、Flask类中的dispatch_request()方法

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
    
       # 根据rule.endpoint找到app.view_functions中对应的处理函数，然后将req.view_args传入，
       # 进行视图函数处理，最后将结果返回
    return self.view_functions[rule.endpoint](**req.view_args)