[Python自学] Flask框架 (3) (路由、CBV、自定义正则动态路由、请求处理流程、蓝图)

一、路由系统

1.浅析@app.route的源码

我们使用@app.route("/index")可以给视图函数加上路由映射。我们分析一下@app.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

可以看到，装饰器的核心就是add_url_rule()函数。这里的self就是Flask的实例app。因为是app调用的route。

也就是说，我们不使用装饰器，也可以直接调用该函数实现路由映射：

def test():
    return 'test'


# 使用app.add_url_rule代替@app.route
# 第一个参数就是url，第二个参数是endpoint（即路由name），第三个参数为视图函数引用
app.add_url_rule('/test', None, test)

执行结果：

 可以看到，这种方式实现的路由，也可以正常访问。

2.分析add_url_rule函数

@setupmethod
def add_url_rule(
    self,
    rule,
    endpoint=None,
    view_func=None,
    provide_automatic_options=None,
    **options
):
    if endpoint is None:  # 如果传入的endpoint为None，则使用视图函数的__name__作为endpoint
        endpoint = _endpoint_from_view_func(view_func)
    options["endpoint"] = endpoint  # 将endpoint设置到options中
    methods = options.pop("methods", None)  # 从参数中获取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为None，就去view_func中找methods，如果找不到，则默认为GET
        methods = getattr(view_func, "methods", None) or ("GET",)
    if isinstance(methods, string_types):  # 如果methods是str，则报错，必须是列表
        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中元素全部转换为大写
    # Methods that should always be added
    required_methods = set(getattr(view_func, "required_methods", ()))  # 获取required_methods
    # starting with Flask 0.8 the view_func object can disable and
    # force-enable the automatic options handling.
    if provide_automatic_options is None:  # 获取provide_automatic_options
        provide_automatic_options = getattr(
            view_func, "provide_automatic_options", None
        )
    if provide_automatic_options is None:  # 如果还为None
        if "OPTIONS" not in methods:  # 如果methods中没有OPTIONS
            provide_automatic_options = True  # provide_automatic_options置为True
            required_methods.add("OPTIONS")
        else:
            provide_automatic_options = False  # 如果methods中有，则provide_automatic_options置为False
    # Add the required methods now.
    methods |= required_methods  # 并集
    # 将我们传入的url，endpoint，func等封装起来，成为一个Rule对象
    rule = self.url_rule_class(rule, methods=methods, **options)
    rule.provide_automatic_options = provide_automatic_options
    # 将封装好的Rule对象添加到Map类的对象中
    self.url_map.add(rule)
    if view_func is not None:  # 传入的视图函数是否为空，这里不为空
        old_func = self.view_functions.get(endpoint)  # 去view_functions字典中看看有没有同名的视图函数
        if old_func is not None and old_func != view_func:  # 如果有同名视图函数，且函数不是我们当前传入的函数，则报错
            raise AssertionError(
                "View function mapping is overwriting an "
                "existing endpoint function: %s" % endpoint  # 报错：存在同名的视图函数
            )
        # 如果endpoint没有冲突，则将视图函数加入view_functions字典中
        self.view_functions[endpoint] = view_fun

这段代码主要的功能就是，将我们传入的url、endpoint、methods等一系列路由参数，封装成一个Rule对象，然后添加到Map对象中。然后判断是否存在endpoint冲突的视图函数，如果没有，则将 endpoint:视图函数引用 键值对存放在app.view_functions字典中，该字典主要就是用来检查endpoint的冲突问题。

所以从这里可以看出，我们在写路由的时候，尽量不要让endpoint重名，如果一定要重名，则函数必须是相同的（例如两个url对应一个视图函数的场景）。例如：

@app.route('/test2', endpoint='t1')
@app.route('/test', endpoint='t1')
def test():
    return 'test'

3.@app.route装饰器的参数

@app.route和app.add_url_rule参数:

    rule,   # URL规则
    view_func,   # 视图函数名称
    defaults = None,   # 默认值, 当URL中无参数，函数需要参数时，使用defaults = {'k': 'v'}为函数提供参数
    endpoint = None,   # 名称，用于反向生成URL，即： url_for('名称')
    methods = None,   # 允许的请求方式，如：["GET", "POST"]

    strict_slashes = None,   # 对URL最后的 / 符号是否严格要求，如：
        例如：
            @app.route('/index', strict_slashes=False)  #访问 http:// www.xx.com/index/ 或http://www.xx.com/index 均可
            @app.route('/index', strict_slashes=True)  #仅访问 http://www.xx.com/index

    indexredirect_to = None,  # 重定向到指定地址 如：
        例如：
            @app.route('/index/<int:nid>', redirect_to='/home/<nid>')
            或
            def func(adapter, nid):
                return "/home/888"
            @app.route('/index/<int:nid>', redirect_to=func)


    subdomain = None,  # 子域名访问，什么是子域名：主干域名是www.leeoo.com  admin.leeoo.com就是admin子域名
        例如：
            from flask import Flask, views, url_for

            app = Flask(import_name=__name__)
            # 配置服务器地址和端口
            app.config['SERVER_NAME'] = 'leeoo.com:5000'

            # 当访问admin.leeoo.com/时才会走这个路由
            @app.route("/", subdomain="admin")
            def static_index():
                """Flask supports static subdomains
                This is available at static.your-domain.tld"""
                return "static.your-domain.tld"

            # 动态子域名，访问user1.leeoo.com/dynamic，则相当于将'user1'作为参数传入username_index()视图函数
            @app.route("/dynamic", subdomain="<username>")
            def username_index(username):
                """Dynamic subdomains are also supported
                Try going to user1.your-domain.tld/dynamic"""
                return username + ".your-domain.tld"

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

二、CBV

1.Flask中的CBV

在Flask中也可以使用类似Django的CBV。

from flask import views


class UserView(views.MethodView):
    def get(self, *args, **kwargs):
        return 'GET'

    def post(self, *args, **kwargs):
        return 'POST'


# CBV不能使用装饰器添加路由，只能使用app.add_url_rule()，注意as_view()的参数会被传递给view_func.__name__，然后会赋值给endpoint
app.add_url_rule('/user', None, UserView.as_view("userview"))

Flask的CBV和django的很类似。当用户的请求到达时，通过MethodView类的dispatch_request()方法，来反射到对应的get或post等视图函数。如下源码所示：

def dispatch_request(self, *args, **kwargs):
    # 用户请求类型request.method先转化为小写，然后看视图类中是否存在对应的方法
    meth = getattr(self, request.method.lower(), None)
    # If the request method is HEAD and we don't have a handler for it
    # retry with GET.
    if meth is None and request.method == "HEAD":
        meth = getattr(self, "get", None)
    # 如果meth为None，则说明用户请求类型没有对应的处理函数，报错
    assert meth is not None, "Unimplemented method %r" % request.method
    # 否则调用对应视图函数
    return meth(*args, **kwargs)

2.视图类的静态属性

from flask import views


# 实现一个自定义装饰器
def wrapper(func):
    def inner(*args, **kwargs):
        return func(*args, **kwargs)

    return inner


class UserView(views.MethodView):
    methods = ['GET']  # 限制支持的请求类型
    decorators = [wrapper, ]  # 在这里使用自定义装饰器，会自动批量添加到各个视图函数

    def get(self, *args, **kwargs):
        return 'GET'

    def post(self, *args, **kwargs):
        return 'POST'


app.add_url_rule('/user', None, UserView.as_view("userview"))

我们可以定义静态属性methods来限制该视图类接收的请求类型。可以定义decorators来批量的对类中的视图函数（get、post...函数）添加自定义装饰器（当然也可以自己手动给需要的视图函数添加）。

三、自定义支持正则的动态路由

我们在使用Flask的动态路由时，Flask默认为我们提供了几种数据类型。参考：[Python自学] Flask框架 (1) (Flask介绍、配置、Session、路由、请求和响应、Jinjia2模板语言、视图装饰器)

1.Flask默认支持的动态参数数据类型

我们可以在app.url_map.converters中看到Flask默认支持的数据类型：

#: the default converter mapping for the map.
DEFAULT_CONVERTERS = {
    "default": UnicodeConverter,
    "string": UnicodeConverter,
    "any": AnyConverter,
    "path": PathConverter,
    "int": IntegerConverter,
    "float": FloatConverter,
    "uuid": UUIDConverter,
}

该字典中，key为支持的类型名，value即为提供转换功能的转换器。

如果我们想要Flask的动态路由支持正则表达式，则需要自己定义一个正则转换器，并添加到app.url_map.converters中。

2.自定义正则转换器

from werkzeug.routing import BaseConverter


class RegexConverter(BaseConverter):
    """
    自定义URL匹配正则表达式
    """

    def __init__(self, map, regex):
        super(RegexConverter, self).__init__(map)
        self.regex = regex

    def to_python(self, value):
        """
        路由匹配时，匹配成功后传递给视图函数中参数的值
        :param value:
        :return:
        """
        return value

    def to_url(self, value):
        """
        使用url_for反向生成URL时，传递的参数经过该方法处理，返回的值用于生成URL中的参数
        :param value:
        :return:
        """
        val = super(RegexConverter, self).to_url(value)
        return val


# 添加到flask中
app.url_map.converters['regex'] = RegexConverter


@app.route('/index/<regex("\d+-\d+"):nid>')
def index(nid):
    print(url_for('index', nid='888-999'))
    return 'Index'

这样，我们就可以在动态路由中，使用正则表达式了。但是注意，这里传递进来的nid是字符串格式（我们也可以在RegexConverter类的to_python中对其进行处理）。

四、Flask请求处理流程

1.启动服务器

我们知道，最简单的Flask代码如下：

from flask import Flask

app = Flask(__name__)


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

Flask是建立在 werkzeug 这个WSGI服务器上的。

当app.run()运行Flask的时候，底层的werkzeug会开始监听指定的端口，准备接受用户请求。

我们可以在Flask类中的run方法找到如下代码：

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

这个run_simple的第三个参数就是满足WSGI协议调用的方法。这里传入了self，这个self就是代指app对象自己。所以当服务器接收到请求时，会调用app()，其实就是调用app中的__call__()方法。

2.接收请求

我们看Flask类中__call__的源代码：

def __call__(self, environ, start_response):
    """The WSGI server calls the Flask application object as the
    WSGI application. This calls :meth:`wsgi_app` which can be
    wrapped to applying middleware."""
    return self.wsgi_app(environ, start_response)

这个__call__方法是在请求到达的时候才会被调用。而被调用时参数是由werkzeug服务器传入的，其中environ是请求相关的信息，而start_response是服务器提供给Flask框架用来封装响应头的函数引用。

可以参考：[Python之路] 实现简易HTTP服务器与MINI WEB框架（利用WSGI实现服务器与框架解耦）中WSGI原理。

3.处理请求和Session

所有Flask框架的源码都是从wsgi_app()这个函数开始的：

def wsgi_app(self, environ, start_response):
    # 1.ctx = RequestContext(self, environ)
    #   ctx.request = Request(environ)
    #   ctx.session = None
    ctx = self.request_context(environ)
    error = None
    try:
        try:
            # 2.将ctx对象加入上下文管理，
            # 3.执行 SecureCookieSessioninterface.open_session，去cookie中获取session值，并给ctx.session重新赋值
            ctx.push()
            # 4.这里调用视图函数
            #   app.dispatch_request()调用视图函数
            # 5.视图函数执行完毕后，调用app.finalize_request()，进行善后工作
            #   在finalize_request中调用process_response，将用户新设置的session加密序列化后写入response中，这里调用的是SecureCookieSessioninterface.save_session
            response = self.full_dispatch_request()
        except Exception as e:
            error = e
            response = self.handle_exception(e)
        except:  # noqa: B001
            error = sys.exc_info()[1]
            raise
        return response(environ, start_response)
    finally:
        if self.should_ignore_error(error):
            error = None
        # 5.视图函数处理完请求，返回了响应之后，清空该次请求在上下文中的数据
        ctx.auto_pop(error)

ctx是app.request_context(environ)中返回的RequestContext实例，并将self和environ传递进去：

def request_context(self, environ):
    # 实例化RequestContext,传入app和environ
    return RequestContext(self, environ)

再看RequestContext类的构造函数：

def __init__(self, app, environ, request=None, session=None):
    # Flask实例app
    self.app = app
    # 这里request我们没有传入，一定为空
    if request is None:
        # request_class是Request类，所以request是Request类的一个实例，并封装了environ（得到我们使用的request）
        request = app.request_class(environ)
    self.request = request
    self.url_adapter = None
    try:
        self.url_adapter = app.create_url_adapter(self.request)
    except HTTPException as e:
        self.request.routing_exception = e
    # 闪现初始化为None
    self.flashes = None
    # session初始化为None
    self.session = session
    self._implicit_app_ctx_stack = []
    self.preserved = False
    self._preserved_exc = None
    self._after_request_functions = []

4.请求处理流程图

五、蓝图

1.修改Flask项目目录结构

在划分目录之前，我们的static目录、templates目录以及写视图函数的app.py文件都位于项目根目录下。

我们对目录进行以下修改：

 

 

1）项目根目录下创建项目同名目录my_flask目录，以及manage.py文件。以后我们的Flask项目就从manage.py启动，而不是以前的app.py

2）在创建好的my_flask目录下，创建static、templates、views目录，以及__init__.py文件。其中static存放静态文件，templates存放模板、view存放视图函数py文件，__init__.py中会创建app实例（Flask对象）。

2.实现my_flask目录下的__init__.py

from flask import Flask


# 封装一个函数，用来生成Flask实例，并返回
def create_app():
    app = Flask(__name__)
    return app

3.实现根目录下的manage.py

# 从my_flask包中导入create_app函数
from my_flask import create_app

# 创建app实例
app = create_app()

if __name__ == '__main__':
    # 运行Flask
    app.run()

manage.py作为整个Flask项目的入口。

4.视图函数分类

我们的视图函数都应该放在views目录下，可以对其进行分门别类，例如登录类的视图函数在login.py中实现，用户信息类的视图函数在user.py中实现。

 

 

login.py和user.py的实现：

# login.py文件

# 导入蓝图模块
from flask import Blueprint, render_template

# 定义一个蓝图对象
lg = Blueprint('lg', __name__)


# 使用蓝图来调用装饰器（而不是使用app）
@lg.route('/login')
def login():
    return render_template('login.html', msg="这是Login页面")

# user.py文件

from flask import Blueprint, render_template

us = Blueprint('us', __name__, template_folder='./templates')


@us.route('/user_list')
def user_list():
    return render_template('user_list.html', msg="这里是USER LIST")

我们通过在每个视图实现文件中都定义一个蓝图实例，然后利用蓝图实例来调用route装饰器给视图函数添加路由映射。

 

但是，使用了蓝图实例后，还需要将蓝图和app实例建立关系：

# my_flask/__init__.py文件

from flask import Flask
from .views.login import lg
from .views.user import us


def create_app():
    app = Flask(__name__)
    app.register_blueprint(lg)
    app.register_blueprint(us)
    return app

这样，我们就成功的利用蓝图实现了视图函数的分类，让我们的项目更清晰明了。

5.蓝图指定模板目录

我们看到，在4.节的user.py中，蓝图的参数多了一个template_folder='./templates'。

这个参数的意思是，该蓝图可以单独指定自己的视图函数中的render_template使用的模板在哪里查找。

但是，需要注意的是，即使设置了template_folder参数，render_template也会先去全局的templates目录中查找，如果没有对应的模板，才会去蓝图中指定的目录中寻找。

我们调整目录结构：

位于项目同名目录my_flask下的templates为全局模板目录。这个目录是所有视图函数默认优先查找的目录。

而views中的templates目录，是我们另外任意创建的一个目录（目录名不一定叫templates）。这个目录可以被views中py文件中定义的蓝图所指定。

如下代码所示：

# user.py

from flask import Blueprint, render_template

us = Blueprint('us', __name__, template_folder='./templates')


@us.route('/user_list')
def user_list():
    return render_template('user_list.html', msg="这里是USER LIST")

user.py中定义蓝图的时候，指定了views/templates目录。

当我们访问/user_list页面的时候，render_template函数会先去全局的templates目录中查找user_list.html模板。结果为：

 而当我们删除全局templates中的user_list.html文件，只留下views/templates中的user_list.html文件，结果变为：

 

优先级总结：全局模板目录 > 蓝图实例化指定的模板目录

6.蓝图路由前缀

在创建蓝图实例时，可以为其相关的所有路由设置一个前缀：

us = Blueprint('us', __name__, template_folder='./templates',url_prefix='/user')


@us.route('/user_list')
def user_list():
    return render_template('user_list.html', msg="这里是USER LIST")

这里我们使用url_prefix参数设置了一个前缀"/user"。

以后我们要访问/user_list页面的时候，就需要在url中多加一层"/user"：

# 原本的访问URL
http://127.0.0.1:5000/user_list

# 加了前缀后的访问URL
http://127.0.0.1:5000/user/user_list

只要使用该蓝图实例来调用装饰器的路由映射，都需要加上该前缀。这种功能有点类似于django中的路由分发，但是又更加的灵活。

 

##