Python Web Flask源码解读(三)——模板渲染过程

关于我 编程界的一名小小程序猿,目前在一个创业团队任team lead,技术栈涉及Android、Python、Java和Go,这个也是我们团队的主要技术栈。 Github: 微信公众号:angrycode

前面对 Flask启动流程路由原理都进行了源码走读。今天我们看看模板渲染的过程。

0x00 使用模板


from flask import render_template

def hello(name=None):
    return render_template('hello.html', name=name)

在项目目录下需要有一个 templates目录,并创建了一个 hello.html文件



<!doctype html>
<title>Hello from Flask</title>
{% if name %}
  <h1>Hello {{ name }}!</h1>
{% else %}
  <h1>Hello, World!</h1>
{% endif %}

这个模板中 name是参数,通过调用 render_template方法就可以根据参数实现 html模板文件的渲染。

0x01 Flask.render_template

def render_template(template_name, **context):
    """Renders a template from the template folder with the given

    :param template_name: the name of the template to be rendered
    :param context: the variables that should be available in the
                    context of the template.
    return current_app.jinja_env.get_template(template_name).render(context)

方法的注释很清楚,从 templates文件夹中找到名称为 template_name的文件进行渲染。其中 current_app是通过以下语句初始化

_request_ctx_stack = LocalStack()
current_app = LocalProxy(lambda:

LocalStack就是一个栈的实现类。而 _request_ctx_stack是在 Flask.request_context()方法中将当前的上下文实例 push到栈里面的

def request_context(self, environ):
    """Creates a request context from the given environment and binds
    it to the current context.  This must be used in combination with
    the `with` statement because the request is only bound to the
    current context for the duration of the `with` block.

    Example usage::

        with app.request_context(environ):

    :params environ: a WSGI environment
    return _RequestContext(self, environ)

_RequestContext类实现了上下文管理器协议,它可以在 with语句中使用

class _RequestContext(object):
    """The request context contains all request relevant information.  It is
    created at the beginning of the request and pushed to the
    `_request_ctx_stack` and removed at the end of it.  It will create the
    URL adapter and request object for the WSGI environment provided.

    def __init__(self, app, environ): = app
        self.url_adapter = app.url_map.bind_to_environ(environ)
        self.request = app.request_class(environ)
        self.session = app.open_session(self.request)
        self.g = _RequestGlobals()
        self.flashes = None

    def __enter__(self):

    def __exit__(self, exc_type, exc_value, tb):
        # do not pop the request stack if we are in debug mode and an
        # exception happened.  This will allow the debugger to still
        # access the request object in the interactive shell.
        if tb is None or not

执行 __enter__()时操作 push,退出 with语句时就执行 pop操作。 回到 request_context()方法,它是在 wsgi_app()中被调用的

def wsgi_app(self, environ, start_response):
    """The actual WSGI application.  This is not implemented in
    `__call__` so that middlewares can be applied:

        app.wsgi_app = MyMiddleware(app.wsgi_app)

    :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
    with self.request_context(environ):
        rv = self.preprocess_request()
        if rv is None:
            rv = self.dispatch_request()
        response = self.make_response(rv)
        response = self.process_response(response)
        return response(environ, start_response)

从路由原理文章的分析知道, wsgi_app()在服务端接收到客户端请求时就会执行。所以当请求来临时,就会把当前 Flask实例的请求上下文实例保存到栈实例 _request_ctx_stack中;请求处理后,就从栈里面弹出当前请求的上下文实例。

LocalProxy是一个代理类,它的构造函数传递了一个 lambda表达式。这个操作就把当前的上下文实例通过 LocalProxy进行了封装,即 current_app是当前 Flask实例的上下文的代理。所以当 current_app.jinja_env这个语句其实就是访问 Flask的实例属性 jinja_env,这个属性是在 Flask的构造函数中进行初始化的。

class Flask(object):
    #: 源码太长了省略
    #: options that are passed directly to the Jinja2 environment
    jinja_options = dict(
        extensions=['jinja2.ext.autoescape', 'jinja2.ext.with_']

    def __init__(self, package_name):
        #: 源码太长省略部分源码
        #: the Jinja2 environment.  It is created from the
        #: :attr:`jinja_options` and the loader that is returned
        #: by the :meth:`create_jinja_loader` function.
        self.jinja_env = Environment(loader=self.create_jinja_loader(),

jinja_env是一个 Environment实例。这个是 jinja模板引擎提供的类, Flask框架的模板渲染就是通过 jinja来实现的。 Environment需要一个 loader,是通过以下方法获取的

def create_jinja_loader(self):
    """Creates the Jinja loader.  By default just a package loader for
    the configured package is returned that looks up templates in the
    `templates` folder.  To add other loaders it's possible to
    override this method.
    if pkg_resources is None:
        return FileSystemLoader(os.path.join(self.root_path, 'templates'))
    return PackageLoader(self.package_name)

默认情况下是从 templates目录下构造一个 FileSystemLoader的实例,这个类的作用就是从文件系统中加载模板文件的。

0x02 Environment.get_template

def get_template(self, name, parent=None, globals=None):
    """Load a template from the loader.  If a loader is configured this
    method ask the loader for the template and returns a :class:`Template`.
    If the `parent` parameter is not `None`, :meth:`join_path` is called
    to get the real template name before loading.

    The `globals` parameter can be used to provide template wide globals.
    These variables are available in the context at render time.

    If the template does not exist a :exc:`TemplateNotFound` exception is

    .. versionchanged:: 2.4
       If `name` is a :class:`Template` object it is returned from the
       function unchanged.
    if isinstance(name, Template):
        return name
    if parent is not None:
        name = self.join_path(name, parent)
    return self._load_template(name, self.make_globals(globals))

get_template()方法内部调用了 _load_template()方法

def _load_template(self, name, globals):
    if self.loader is None:
        raise TypeError('no loader for this environment specified')
    if self.cache is not None:
        template = self.cache.get(name)
        if template is not None and (not self.auto_reload or \
            return template
    template = self.loader.load(self, name, globals)
    if self.cache is not None:
        self.cache[name] = template
    return template

_load_template()方法首先会检查是否有缓存,如果缓存可用就使用缓存;缓存不可用就使用 loader加载模板,这个 loader就是前面提到的 FileSystemLoader的实例(默认情况下)。

0x03 BaseLoader.load

def load(self, environment, name, globals=None):
    # 省略部分源码
    return environment.template_class.from_code(environment, code, globals, uptodate)

BaseLoaderFileSystemLoader的基类。这个 load方法实现了模板的编译、加载等逻辑。最后是使用 environment.template_class.from_code()方法。其中 template_classTemplate类,它代表编译后的模板对象。from_codeTemplate类的静态方法,可以用来创建一个 Template实例。当 load方法返回时,就得到了一个 Template对象。最后回到 render_template方法

def render_template(template_name, **context):
    return current_app.jinja_env.get_template(template_name).render(context)

执行了 Template对象的 render()方法。

0x04 Template.render

def render(self, *args, **kwargs):
    """This function accepts either a dict or some keyword arguments which
    will then be the context the template is evaluated in.  The return
    value will be the rendered template.

    :param context: the function accepts the same arguments as the
                    :class:`dict` constructor.
    :return: the rendered template as string
    ns = self.default_context.copy()
    if len(args) == 1 and isinstance(args[0], utils.MultiDict):
    if kwargs:
    context = Context(ns, self.charset, self.errors)
    exec self.code in context.runtime, context
    return context.get_value(self.unicode_mode)

这个方法接收一个 dict类型参数,用于给模板传递参数。该方法的核心是执行 exec函数。execPython内置函数,它可以动态的执行 Python代码。

0x05 总结一下

Flask使用 Jinja作为模板引擎。执行路径为

Flask.render_template => Environment.get_template => Template.render => exec

0x06 学习资料


原文发布于微信公众号 - 终身开发者(AngryCode)





0 条评论
登录 后参与评论