时间：2021-07-01 10:21:17 帮助过：21人阅读
def generate(self, writer):
method_name = "apply%d" % writer.apply_counter
writer.apply_counter += 1
writer.write_line("def %s():" % method_name, self.line)
with writer.indent():
writer.write_line("_buffer = []", self.line)
writer.write_line("_append = _buffer.append", self.line)
self.body.generate(writer)
writer.write_line("return _utf8('').join(_buffer)", self.line)
writer.write_line("_append(%s(%s()))" % (
self.method, method_name), self.line)
简单来说，这个函数做了两件事情：
定义了一个python文件全局函数叫做applyXXX():，其中的XXX是一个整形的，自增的值，返回值是一个utf8字符串。
执行这个applyXXX函数，将此函数的输出再作为self.method这个函数的输入。
所以，如果一个类似于这样的模板
{%apply linkify%} {{address}} {%end%}
会得到一个类似于如下的输出：
r = applyXXX() r = linkify(r) _append(r)
tornado的template机制，本质上讲，就是允许开发者已HTML + template marker的方式来编写视图模板，但是在背后，tornado会把这些视图模板通过template的处理，变成可编译的python代码。
拿autumn-sea上面的代码作为例子，比较容易理解：
View Template
{{ title }}
hello! {{ name }}
处理后
_buffer = []
_buffer.append('\\n\\n')
_tmp = title
if isinstance(_tmp, str): _buffer.append(_tmp)
elif isinstance(_tmp, unicode): _buffer.append(_tmp.encode('utf-8'))
else: _buffer.append(str(_tmp))
_buffer.append(' \\n\\n\\n')
_buffer.append('hello! ')
_tmp = name
if isinstance(_tmp, str): _buffer.append(_tmp)
elif isinstance(_tmp, unicode): _buffer.append(_tmp.encode('utf-8'))
else: _buffer.append(str(_tmp))
_buffer.append('\\n\\n\\n')
return ''.join(_buffer)\n"
实例剖析
tornado的模板基本都在template.py这个文件中，短短800多行代码就实现了基本可用的模板，让我们慢慢揭开她的面纱。
首先我们看看tornado是如何编译模板的，下面是个简单的模板
t = Template("""\
{%if names%}
{% for name in names %}
{{name}}
{%end%}
{%else%}
no one
{%end%}
""")
tornado最后编译代码如下:
def _tt_execute(): #:0 _tt_buffer = [] # :0 _tt_append = _tt_buffer.append # :0 if names: # :1 _tt_append('\n ') # :2 for name in names: # :2 _tt_append('\n ') # :3 _tt_tmp = name # :3 if isinstance(_tt_tmp, _tt_string_types): _tt_tmp = _tt_utf8(_tt_tmp) # :3 else: _tt_tmp = _tt_utf8(str(_tt_tmp)) # :3 _tt_tmp = _tt_utf8(xhtml_escape(_tt_tmp)) # :3 _tt_append(_tt_tmp) # :3 _tt_append('\n ') # :4 pass # :2 _tt_append('\n') # :5 pass # :5 else: # :5 _tt_append('\nno one\n') # :7 pass # :1 _tt_append('\n') # :8 return _tt_utf8('').join(_tt_buffer) # :0 是的，你没看错，tornado编译就是将之翻译成一个个代码块，最后通exec传递我们给的参数命名空间执行_tt_execute函数。
在我们上面的模板中包含了4种预定义的NODE节点，_ControlBlock,_Expression,_TEXT,每种Node节点都有自己的生成方式。
比如说_Expression表达式节点，也就是我们模板中的{{name}}，当_parse解析时发现'{'后面还是'{'就认为是表达式节点，
class _Expression(_Node): def __init__(self, expression, line, raw=False): self.expression = expression self.line = line self.raw = raw def generate(self, writer): writer.write_line("_tt_tmp = %s" % self.expression, self.line) writer.write_line("if isinstance(_tt_tmp, _tt_string_types):" " _tt_tmp = _tt_utf8(_tt_tmp)", self.line) writer.write_line("else: _tt_tmp = _tt_utf8(str(_tt_tmp))", self.line) if not self.raw and writer.current_template.autoescape is not None: # In python3 functions like xhtml_escape return unicode, # so we have to convert to utf8 again. writer.write_line("_tt_tmp = _tt_utf8(%s(_tt_tmp))" % writer.current_template.autoescape, self.line) writer.write_line("_tt_append(_tt_tmp)", self.line)最后生成时会调用节点的generate方法，self.expression就是上面的name，所以当exec的时候就会把name的值append到内部的列表中。
像if,for等都是控制节点，他们的定义如下:
class _ControlBlock(_Node): def __init__(self, statement, line, body=None): self.statement = statement self.line = line self.body = body def each_child(self): return (self.body,) def generate(self, writer): writer.write_line("%s:" % self.statement, self.line) with writer.indent(): self.body.generate(writer) # Just in case the body was empty writer.write_line("pass", self.line)
控制节点的generate方法有点意义，因为if，for等是下一行是需要缩进的，所以调用了with writer.indent继续缩进控制，可以看下
_CodeWriter的indent方法。
节点中比较有意思的是_ExtendsBlock，这是实现目标基础的节点，
class _ExtendsBlock(_Node): def __init__(self, name): self.name = name我们发现并没有定义generate方法，那当生成继承节点时不是会报错吗？让我们看一段事例
loader = Loader('.') t=Template("""\ {% extends base.html %} {% block login_name %}hello world! {{ name }}{% end %} """,loader=loader)当前目录下base.html如下:
{{ title }} {% block login_name %}hello! {{ name }}{% end %}我们可以看看解析后的节点,
由于我们继承了base.html，所以我们的应该以base.html的模板生成，并使用新定义的block代替base.html中的block，
这是很正常的思路，tornado也的确是这么干的，只不过处理的并不是在_ExtendsBlock。
而实在Template的_generate_python中
def _generate_python(self, loader, compress_whitespace): buffer = StringIO() try: # named_blocks maps from names to _NamedBlock objects named_blocks = {} ancestors = self._get_ancestors(loader) ancestors.reverse() for ancestor in ancestors: ancestor.find_named_blocks(loader, named_blocks) writer = _CodeWriter(buffer, named_blocks, loader, ancestors[0].template, compress_whitespace) ancestors[0].generate(writer) return buffer.getvalue() finally: buffer.close() def _get_ancestors(self, loader): ancestors = [self.file] for chunk in self.file.body.chunks: if isinstance(chunk, _ExtendsBlock): if not loader: raise ParseError("{% extends %} block found, but no " "template loader") template = loader.load(chunk.name, self.name) ancestors.extend(template._get_ancestors(loader)) return ancestors_generate_python中调用_get_ancestors获取当前模板的父模板，我们看到如果当前模板的_FILE节点中有_ExtendsBlock就代表有父模板并通过loader.load加载父模板，此时父模板已经是解析过的_FILE节点了。所以，在上面的模板中，ancestors是[当前模板_FILE节点，父模板_FILE节点]，ancestors.reverse()后其实ancestors[0]就是父模板，我们看到最后是通过ancestors[0].generate(writer)来生成代码的。那当前模板是如何替换父模板的block内容呢？
看上图，block login_name通过解析为_NamedBlock，在_generate_python中通过调用ancestor.find_named_blocks来替换
父模板的_NamedBlock的。
for ancestor in ancestors: ancestor.find_named_blocks(loader, named_blocks) ancestor其实就是_FILE节点，find_named_blocks将遍历_FILE节点中所有节点并调用find_named_blocks class _NamedBlock(_Node): def find_named_blocks(self, loader, named_blocks): named_blocks[self.name] = self _Node.find_named_blocks(self, loader, named_blocks)其它节点find_named_blocks都没有做什么事，_NamedBlock通过named_blocks[self.name] = self替换为当前模板的_NamedBlock，因为ancestors父模板在前，当前模板在后，所以最后使用的是当前模板的_NamedBlock。
生成代码后generate将在给定的命名空间中exec代码
def generate(self, **kwargs): """Generate this template with the given arguments.""" namespace = { "escape": escape.xhtml_escape, "xhtml_escape": escape.xhtml_escape, "url_escape": escape.url_escape, "json_encode": escape.json_encode, "squeeze": escape.squeeze, "linkify": escape.linkify, "datetime": datetime, "_tt_utf8": escape.utf8, # for internal use "_tt_string_types": (unicode_type, bytes_type), # __name__ and __loader__ allow the traceback mechanism to find # the generated source code. "__name__": self.name.replace('.', '_'), "__loader__": ObjectDict(get_source=lambda name: self.code), } namespace.update(self.namespace) namespace.update(kwargs) exec_in(self.compiled, namespace) execute = namespace["_tt_execute"] # Clear the traceback module's cache of source data now that # we've generated a new template (mainly for this module's # unittests, where different tests reuse the same name). linecache.clearcache() return execute()所以在模板中可以使用datetime等，都是通过在这里注入到模板中的，当然还有其它的是通过
web.py 中get_template_namespace注入的
def get_template_namespace(self): """Returns a dictionary to be used as the default template namespace. May be overridden by subclasses to add or modify values. The results of this method will be combined with additional defaults in the `tornado.template` module and keyword arguments to `render` or `render_string`. """ namespace = dict( handler=self, request=self.request, current_user=self.current_user, locale=self.locale, _=self.locale.translate, static_url=self.static_url, xsrf_form_html=self.xsrf_form_html, reverse_url=self.reverse_url ) namespace.update(self.ui) return namespace我们再来看看tornado的模板是如何对UI模块的支持的。
{% for entry in entries %} {% module Entry(entry) %} {% end %}在使用module时将会生成_Module节点
class _Module(_Expression): def __init__(self, expression, line): super(_Module, self).__init__("_tt_modules." + expression, line, raw=True)我们看到其实_Module节点是继承自_Expression节点，所以最后执行的是_tt_modules.Entry(entry)
_tt_modules定义在web.py的RequestHandler中
self.ui["_tt_modules"] = _UIModuleNamespace(self,application.ui_modules)并通过上文的get_template_namespace中注入到模板中。
class _UIModuleNamespace(object): """Lazy namespace which creates UIModule proxies bound to a handler.""" def __init__(self, handler, ui_modules): self.handler = handler self.ui_modules = ui_modules def __getitem__(self, key): return self.handler._ui_module(key, self.ui_modules[key]) def __getattr__(self, key): try: return self[key] except KeyError as e: raise AttributeError(str(e))所以当执行_tt_modules.Entry(entry)时先访问_UIModuleNamespace的__getattr__,后访问__getitem__，最后调用
handler._ui_module(key, self.ui_modules[key])，
def _ui_module(self, name, module): def render(*args, **kwargs): if not hasattr(self, "_active_modules"): self._active_modules = {} if name not in self._active_modules: self._active_modules[name] = module(self) rendered = self._active_modules[name].render(*args, **kwargs) return rendered return render_tt_modules.Entry(entry)中entry将会传给_ui_module内部的render，也就是args=entry
self._active_modules[name] = module(self)此时就是实例化后的UIModule，调用render获取渲染后的内容
class Entry(tornado.web.UIModule): def render(self, entry, show_comments=False): return self.render_string( "module-entry.html", entry=entry, show_comments=show_comments)当然如果你觉得这么做费事，也可以使用tornado自带的TemplateModule，它继承自UIModule，
你可以这么用
{% module Template("module-entry.html", show_comments=True) %}在module_entry.html中可以通过set_resources引用需要的静态文件
{{ set_resources(embedded_css=".entry { margin-bottom: 1em; }") }}这里需要注意的是:只能在Template引用的html文件中使用set_resources函数，因为set_resources是TemplateModule.render的内部函数
class TemplateModule(UIModule): """UIModule that simply renders the given template. {% module Template("foo.html") %} is similar to {% include "foo.html" %}, but the module version gets its own namespace (with kwargs passed to Template()) instead of inheriting the outer template's namespace. Templates rendered through this module also get access to UIModule's automatic javascript/css features. Simply call set_resources inside the template and give it keyword arguments corresponding to the methods on UIModule: {{ set_resources(js_files=static_url("my.js")) }} Note that these resources are output once per template file, not once per instantiation of the template, so they must not depend on any arguments to the template. """ def __init__(self, handler): super(TemplateModule, self).__init__(handler) # keep resources in both a list and a dict to preserve order self._resource_list = [] self._resource_dict = {} def render(self, path, **kwargs): def set_resources(**kwargs): if path not in self._resource_dict: self._resource_list.append(kwargs) self._resource_dict[path] = kwargs else: if self._resource_dict[path] != kwargs: raise ValueError("set_resources called with different " "resources for the same template") return "" return self.render_string(path, set_resources=set_resources, **kwargs)人气教程排行
- 384次 1 对Python2.7pandas中的read_excel详解
- 383次 2 Python实现定时弹窗提醒
- 383次 3 python爬虫入门（3）--利用requests构建知乎API
- 382次 4 python如何爬取搜狗微信公众号文章永久链接的思路解析
- 381次 5 python字典的键可以相同吗
- 381次 6 python是一种面向什么的语言？
- 381次 7 python通过pil为png图片填充上背景颜色的方法
- 380次 8 python语言的编程模式有什么
- 380次 9 使用python获取进程pid号的方法
- 380次 10 Python中如何解决无限循环的问题
- 378次 11 怎么解决pip不是内部或外部命令
- 378次 12 python中def是什么意思
- 376次 13 对numpy中数组元素的统一赋值实例
- 374次 14 python的选择语句是什么语句
- 374次 15 Python中构造方法的解析（附示例）
- 373次 16 关于python中引入导入与自定义模块以及外部文件的实例分享
- 372次 17 python如何在不同类之间调用方法
- 372次 18 python中的【//】是什么运算符号
- 371次 19 python中╲t是什么
- 371次 20 python同时给多个变量赋值
