深入解析Python的Tornado框架中内置的模板引擎
template中的_parse方法是模板文法的解析器,而这个文件中一坨一坨的各种node以及block,就是解析结果的承载者,也就是说在经过parse处理过后,我们输入的tornado的html模板就变成了各种block的集合。 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) 简单来说,这个函数做了两件事情: {%apply linkify%} {{address}} {%end%} 会得到一个类似于如下的输出: r = applyXXX() r = linkify(r) _append(r) tornado的template机制,本质上讲,就是允许开发者已HTML + template marker的方式来编写视图模板,但是在背后,tornado会把这些视图模板通过template的处理,变成可编译的python代码。 <html> <head> <title>{{ title }}</title> </head> <body> hello! {{ name }} </body> </html> 处理后 _buffer = [] _buffer.append('<html>n<head>n<title>') _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('</title>n</head>n<body>n') _buffer.append('hello! ') _tmp = name if isinstance(_tmp,unicode): _buffer.append(_tmp.encode('utf-8')) else: _buffer.append(str(_tmp)) _buffer.append('n</body>n</html>n') return ''.join(_buffer)n" 实例剖析 t = Template(""" {%if names%} {% for name in names %} {{name}} {%end%} {%else%} no one {%end%} """) tornado最后编译代码如下: def _tt_execute(): # <string>:0 _tt_buffer = [] # <string>:0 _tt_append = _tt_buffer.append # <string>:0 if names: # <string>:1 _tt_append('n ') # <string>:2 for name in names: # <string>:2 _tt_append('n ') # <string>:3 _tt_tmp = name # <string>:3 if isinstance(_tt_tmp,_tt_string_types): _tt_tmp = _tt_utf8(_tt_tmp) # <string>:3 else: _tt_tmp = _tt_utf8(str(_tt_tmp)) # <string>:3 _tt_tmp = _tt_utf8(xhtml_escape(_tt_tmp)) # <string>:3 _tt_append(_tt_tmp) # <string>:3 _tt_append('n ') # <string>:4 pass # <string>:2 _tt_append('n') # <string>:5 pass # <string>:5 else: # <string>:5 _tt_append('nno onen') # <string>:7 pass # <string>:1 _tt_append('n') # <string>:8 return _tt_utf8('').join(_tt_buffer) # <string>:0 是的,你没看错,tornado编译就是将之翻译成一个个代码块,最后通exec传递我们给的参数命名空间执行_tt_execute函数。 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到内部的列表中。 class _ControlBlock(_Node): def __init__(self,statement,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)
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如下: <html> <head> <title>{{ title }}</title> </head> <body> {% block login_name %}hello! {{ name }}{% end %} </body> </html> 我们可以看看解析后的节点, 由于我们继承了base.html,所以我们的应该以base.html的模板生成,并使用新定义的block代替base.html中的block, 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,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内容呢? 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,named_blocks): named_blocks[self.name] = self _Node.find_named_blocks(self,named_blocks) 其它节点find_named_blocks都没有做什么事,_NamedBlock通过named_blocks[self.name] = self替换为当前模板的_NamedBlock,因为ancestors父模板在前,当前模板在后,所以最后使用的是当前模板的_NamedBlock。 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等,都是通过在这里注入到模板中的,当然还有其它的是通过 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,line): super(_Module,self).__init__("_tt_modules." + expression,raw=True) 我们看到其实_Module节点是继承自_Expression节点,所以最后执行的是_tt_modules.Entry(entry) 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__,最后调用 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 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) (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |