資訊專欄INFORMATION COLUMN
摘要：前兩篇文章主要說明了的模板系統(tǒng)將模板文件處理后得到的結(jié)果函數(shù)。生成函數(shù)的代碼這個是模板生成過程中最長最復(fù)雜的一段，會應(yīng)用到的分析功能以及動態(tài)編譯功能。參數(shù)都是一個，表示還未解析的模板內(nèi)容。
前兩篇文章主要說明了web.py的模板系統(tǒng)將模板文件處理后得到的結(jié)果：__template__()函數(shù)。本文主要講述模板文件是如何變成__template__()函數(shù)的。
Render和frender一般來說，更常用的是Render類，該類會處理整個目錄下的模板，還支持緩存和嵌套模板。不過這些其實都和模板本身的解析基本沒關(guān)系，以后再說明這個類的實現(xiàn)和用途。這里我們使用frender()函數(shù)：
def frender(path, **keywords):
"""Creates a template from the given file path.
"""
return Template(open(path).read(), filename=path, **keywords)
這個函數(shù)相當(dāng)簡單，只作了一鍵事情，就是讀取模板文件內(nèi)容，然后交給Template類處理，并且返回一個Template類實例。從這里也可以看出，整個模板的解析，只和Template類有關(guān)，frender是來打雜的。
Template類 Template實例的效果當(dāng)我們根據(jù)一個模板內(nèi)容創(chuàng)建一個Template類實例t后，我們可以調(diào)用該實例，這相當(dāng)于調(diào)用模板對應(yīng)的__template__()函數(shù)，得到的結(jié)果是一個TemplateResult實例。
In [7]: t = web.template.frender("templates/hello.html")
# coding: utf-8
def __template__ (name):
__lineoffset__ = -4
loop = ForLoop()
self = TemplateResult(); extend_ = self.extend
extend_([u"hello, ", escape_(name, True), u"
"])
return self
In [8]: print t("xxxx")
hello, xxxx
In [9]: print type(t("xxxx"))
Template實例化過程
Template實例化過程是把模板轉(zhuǎn)換成HTML內(nèi)容的實質(zhì)性步驟，不過這個過程比較復(fù)雜。但是，概括的來講，這個過程和Template的__init__()函數(shù)中的步驟差不都差不多。
# Template類的__init__()函數(shù)
def __init__(self, text, filename="", filter=None, globals=None, builtins=None, extensions=None):
self.extensions = extensions or []
text = Template.normalize_text(text)
code = self.compile_template(text, filename)
_, ext = os.path.splitext(filename)
filter = filter or self.FILTERS.get(ext, None)
self.content_type = self.CONTENT_TYPES.get(ext, None)
if globals is None:
globals = self.globals
if builtins is None:
builtins = TEMPLATE_BUILTINS
BaseTemplate.__init__(self, code=code, filename=filename, filter=filter, globals=globals, builtins=builtins)
首先把，參數(shù)里除了text以外的參數(shù)忽略掉，然后來看下對text的處理過程（text就是模板的內(nèi)容）。整個過程概括的說有如下步驟：
對text作歸一化處理：text = Template.normalize_text(text)， 主要換行符統(tǒng)一成 ，刪除BOM字符串，將$替換成$$，這個就是簡單的字符串處理。
編譯模板得到編譯后的Python字節(jié)碼code：code = self.compile_template(text, filename)，code就是之前已經(jīng)提到過的__template__()函數(shù)。
調(diào)用父類(BaseTemplate)的__init__()函數(shù)：創(chuàng)建__template__()函數(shù)的執(zhí)行環(huán)境，并且實現(xiàn)可調(diào)用功能。
其他沒有說明的代碼，暫時都可以忽略，不會影響你理解Template的實例化過程。從上面的步驟可以看出，Template實例化的過程主要有兩個：生成__template__()函數(shù)的代碼并編譯，以及創(chuàng)建__template__()函數(shù)的執(zhí)行環(huán)境。
生成__template__()函數(shù)的代碼這個是模板生成過程中最長最復(fù)雜的一段，會應(yīng)用到Python的token分析功能以及動態(tài)編譯功能。還記得第一篇里，我們搭建實驗環(huán)境的時候，修改了web.py源碼，在一個地方插入了一行打印語句么？沒錯，就是這個compile_template()函數(shù)，我們現(xiàn)在來看看它是如何生成__template__()函數(shù)的代碼的。
def compile_template(self, template_string, filename):
code = Template.generate_code(template_string, filename, parser=self.create_parser())
def get_source_line(filename, lineno):
try:
lines = open(filename).read().splitlines()
return lines[lineno]
except:
return None
print code # 上次增加的打印語句
...
很明顯，第一行的調(diào)用就生成了__template__()函數(shù)的代碼。我們繼續(xù)看：
def generate_code(text, filename, parser=None):
# parse the text
parser = parser or Parser()
rootnode = parser.parse(text, filename)
# generate python code from the parse tree
code = rootnode.emit(indent="").strip()
return safestr(code)
generate_code = staticmethod(generate_code)
def create_parser(self):
p = Parser()
for ext in self.extensions:
p = ext(p)
return p
這兩個函數(shù)配合起來使用，意思就是：創(chuàng)建一個沒有擴(kuò)展的Parser實例，用該實例解析模板內(nèi)容得到rootnode，調(diào)用rootnode的emit()函數(shù)得到最終的代碼（__template__()函數(shù)）。所以，問題的關(guān)鍵由轉(zhuǎn)到了Parser類上。
Parser類初探Parser類的parse函數(shù)解析模板內(nèi)容，然后返回一些節(jié)點(diǎn)結(jié)構(gòu)，這種節(jié)點(diǎn)結(jié)構(gòu)的emit方法會產(chǎn)生實際的Python代碼。
class Parser:
"""Parser Base.
"""
def __init__(self):
self.statement_nodes = STATEMENT_NODES
self.keywords = KEYWORDS
def parse(self, text, name=""):
self.text = text
self.name = name
defwith, text = self.read_defwith(text)
suite = self.read_suite(text)
return DefwithNode(defwith, suite)
...
上面的代碼是Template類中用的Parser類的兩個方法，初始化函數(shù)沒啥好說的，parse函數(shù)則是說明了模板解析的最頂層邏輯：
先解析def with這行。
然后解析剩余部分。
最后返回一個DefwithNode實例。
這里不打算細(xì)說整個解析過程（后面專門說），反正知道了Parser類的parse函數(shù)可以返回一個DefwithNode實例，且調(diào)用其emit()方法后能生成最終的代碼即可。
編譯__template__()函數(shù)的代碼在compile_template方法得到模板對應(yīng)的代碼后，就要對這個代碼進(jìn)行編譯，生成Python的字節(jié)碼：
def compile_template(self, template_string, filename):
code = Template.generate_code(template_string, filename, parser=self.create_parser())
...
print code
try:
# compile the code first to report the errors, if any, with the filename
compiled_code = compile(code, filename, "exec")
except SyntaxError, e:
# display template line that caused the error along with the traceback.
...
return compiled_code
到此就完成了Template類實例化過程的第二個步驟：得到了編譯后的模板函數(shù)代碼。
BaseTemplate接下來就是要調(diào)用父類，也就是BaseTemplate類，的初始化方法了：
BaseTemplate.__init__(self, code=code, filename=filename, filter=filter, globals=globals, builtins=builtins)
該方法接受的參數(shù)中，code就是上面編譯出來的字節(jié)碼，globals和builtins是用來構(gòu)建__template__()函數(shù)的運(yùn)行環(huán)境的，記得在web.py的文檔中有說可以修改這兩個的地方么？忘記的話，傳送門。filter函數(shù)是過濾函數(shù)，用來處理生成的HTML內(nèi)容。
globals和builtins如果你的代碼中不指定，默認(rèn)情況下，globals是空的，builtins則包含如下內(nèi)容：
TEMPLATE_BUILTIN_NAMES = [
"dict", "enumerate", "float", "int", "bool", "list", "long", "reversed",
"set", "slice", "tuple", "xrange",
"abs", "all", "any", "callable", "chr", "cmp", "divmod", "filter", "hex",
"id", "isinstance", "iter", "len", "max", "min", "oct", "ord", "pow", "range",
"True", "False",
"None",
"__import__", # some c-libraries like datetime requires __import__ to present in the namespace
]
這些就是Python的全局內(nèi)置函數(shù)的一個子集，你在模板中可以直接使用。
BaseTemplate的初始化這個初始化過程，我們直接看代碼(只列出相關(guān)函數(shù)）：
class BaseTemplate:
def __init__(self, code, filename, filter, globals, builtins):
self.filename = filename
self.filter = filter
self._globals = globals
self._builtins = builtins
if code:
self.t = self._compile(code)
else:
self.t = lambda: ""
def _compile(self, code):
env = self.make_env(self._globals or {}, self._builtins)
exec(code, env)
return env["__template__"]
def make_env(self, globals, builtins):
return dict(globals,
__builtins__=builtins,
ForLoop=ForLoop,
TemplateResult=TemplateResult,
escape_=self._escape,
join_=self._join
)
初始化的時候，主要的工作是調(diào)用self.t = self._compile(code)。_compile()方法先使用make_env()方法構(gòu)造一個函數(shù)運(yùn)行環(huán)境env，里面包含了__template__()函數(shù)會用到的對象，包括默認(rèn)的內(nèi)置函數(shù)，以及TemplateResult等。然后，調(diào)用exec(code, env)在env環(huán)境下執(zhí)行__template__()函數(shù)的定義，最后返回的env["__template"]就是在env環(huán)境下執(zhí)行的__template__()函數(shù)。
注意:*在python2中，exec是一個語句：
The first expression should evaluate to either a Unicode string, a Latin-1 encoded string, an open file object, a code object, or a tuple.
exec還有下面這種形式：
exec code in globals, locals
如果以元組作為參數(shù)，則有如下兩個形式：
exec (code, globals) exec (code, globals, locals)
globals字典中可以插入__builtins__ 對象來設(shè)置內(nèi)置對象的引用，比如上面的make_env()函數(shù)。
Parser類現(xiàn)在可以來看Parser類是如何解析模板，并生成特定的節(jié)點(diǎn)結(jié)構(gòu)的。還是從parse函數(shù)開始：
def parse(self, text, name=""):
self.text = text
self.name = name
defwith, text = self.read_defwith(text)
suite = self.read_suite(text)
return DefwithNode(defwith, suite)
首先調(diào)用read_defwith()方法，將$def with (name)這行分離出來，剩余的都交給read_suite()方法去解析，最后再實例化一個DefwithNode作為解析結(jié)果。整個解析的主要工作是由read_suite()方法完成的。
Parser類的實現(xiàn)慣例 解析函數(shù)Parser類里面實現(xiàn)了如下這些方法：
def read_assignment : function def read_block_section : function def read_expr : function def read_indented_block : function def read_keyword : function def read_node : function def read_section : function def read_statement : function def read_suite : function def read_text : function def read_var : function def readline : function
這些方法的參數(shù)和返回值都遵循同一個模式，先知道一下有助于閱讀代碼。
每個方法都負(fù)責(zé)解析特定的內(nèi)容（方法名可以體現(xiàn)），有的方法內(nèi)部會調(diào)用其他的方法。
參數(shù)都是一個text，表示還未解析的模板內(nèi)容。
返回值都是含有兩個元素的元組，第一個元素是該函數(shù)解析的結(jié)果（字符串或者某個類實例），第二個元素是該函數(shù)處理過后還剩余的模板內(nèi)容（給下個函數(shù)去解析）。
從這個慣例可以看出，整個模板解析的思想是：從模板內(nèi)容頭部開始，一點(diǎn)一點(diǎn)的讀取，一旦所讀取的內(nèi)容可以解析就進(jìn)行解析，剩余的內(nèi)容再繼續(xù)這么處理。
另外，這些解析函數(shù)還有包含關(guān)系，有一些是處理整塊內(nèi)容的函數(shù)，有一些則是處理一行，還有的是處理一個單詞，這也就形成了一個調(diào)用關(guān)系：粗粒度的函數(shù)調(diào)用細(xì)粒度的解析函數(shù)。如下圖所示：
解析節(jié)點(diǎn)上一小節(jié)提到了，解析函數(shù)返回值中的第一個一般都是解析好的節(jié)點(diǎn)類實例。那么什么是解析節(jié)點(diǎn)呢？解析節(jié)點(diǎn)其實就是一些類，這些類都實現(xiàn)了emit()函數(shù)，當(dāng)調(diào)用emit()時，就會產(chǎn)生對應(yīng)的代碼字符串。先來看下有哪些解析節(jié)點(diǎn)吧：
-- TextNode ExpressoinNode LineNode VarNode StatementNode AssignmentNode BlockNode IfNode, ElseNode, ElifNode ForNode CodeNode DefNode SuiteNode DefwithNode
這些節(jié)點(diǎn)的功能基本上從類名稱就可以看出來，有些節(jié)點(diǎn)只是其他節(jié)點(diǎn)的包裝（比如LineNode），有一些則需要處理比較復(fù)雜的情況（比如ForNode）。但是這些節(jié)點(diǎn)作的事情都是可以概括為：處理初始化參數(shù)以便在調(diào)用emit方法的時候能產(chǎn)生正確的代碼。來看兩個例子：
AssignmentNode模板內(nèi)容
$def with (name) $ b = name
函數(shù)內(nèi)容
def __template__ (name):
__lineoffset__ = -4
loop = ForLoop()
self = TemplateResult(); extend_ = self.extend
b = name
return self
我們知道當(dāng)解析到$ b = name這行時，會生成一個AssignmentNode，調(diào)用read_assignment()的代碼在Parser類的read_section()方法里，我們可以模擬一下：
In [16]: node, _ = p.read_assignment(" b = name
")
In [18]: print node
In [20]: print node.emit(" ")
b = name
web.py的模板系統(tǒng)就是這樣針對每個節(jié)點(diǎn)調(diào)用emit()方法來生產(chǎn)最終的代碼的。
ForNode我們再來看復(fù)雜一點(diǎn)的ForNode節(jié)點(diǎn)。
模板內(nèi)容
$def with (name_list)
$for name in name_list:
$name
函數(shù)內(nèi)容
def __template__ (name_list):
__lineoffset__ = -4
loop = ForLoop()
self = TemplateResult(); extend_ = self.extend
for name in loop.setup(name_list):
extend_([escape_(name, True), u"
"])
return self
web.py中調(diào)用創(chuàng)建ForNode實例的方法是read_block_section(),我們可以這么模擬：
In [27]: node = web.template.ForNode("for name in name_list
", " $name
")
In [28]: print node
]>
In [31]: print node.emit(" ")
for name in loop.setup(name_list):
extend_([u" ", escape_(name, True), u"
"])
創(chuàng)建ForNode節(jié)點(diǎn)實例時，是把第一行的循環(huán)控制語句和其他的循環(huán)內(nèi)部代碼分別作為兩個參數(shù)傳遞給ForNode的初始化函數(shù)。ForNode的主要工作是解析第一個參數(shù)，轉(zhuǎn)換為loop.setup()這樣的代碼（為了能夠在模板中支持loop關(guān)鍵字）。然后，調(diào)用父類BlockNode的初始化函數(shù)，主要作用是調(diào)用Parser類的read_suite()方法解析循環(huán)內(nèi)部的代碼，因為我們在循環(huán)內(nèi)部也會使用模板語法（就像上面例子中的$name 被轉(zhuǎn)換成extend_([u" ", escape_(name, True), u" "])）。
class BlockNode:
def __init__(self, stmt, block, begin_indent=""):
self.stmt = stmt
self.suite = Parser().read_suite(block)
self.begin_indent = begin_indent
def emit(self, indent, text_indent=""):
text_indent = self.begin_indent + text_indent
out = indent + self.stmt + self.suite.emit(indent + INDENT, text_indent)
return out
def __repr__(self):
return "" % (repr(self.stmt), repr(self.suite))
class ForNode(BlockNode):
def __init__(self, stmt, block, begin_indent=""):
self.original_stmt = stmt
tok = PythonTokenizer(stmt)
tok.consume_till("in")
a = stmt[:tok.index] # for i in
b = stmt[tok.index:-1] # rest of for stmt excluding :
stmt = a + " loop.setup(" + b.strip() + "):"
BlockNode.__init__(self, stmt, block, begin_indent)
def __repr__(self):
return "" % (repr(self.original_stmt), repr(self.suite))
SuiteNode
SuiteNode內(nèi)部就是一個列表，保存了所有子節(jié)點(diǎn)，調(diào)用SuiteNode的emit()方法時，就是依次調(diào)用子節(jié)點(diǎn)的emit()方法，然后連接成一個字符串：
def emit(self, indent, text_indent=""):
return "
" + "".join([s.emit(indent, text_indent) for s in self.sections])
DefwithNode
DefwithNode作為根節(jié)點(diǎn)，做了兩個事情：
生成__template__()函數(shù)的框架。
調(diào)用suite.emit()生成其余的代碼，并且拼接得到一個完整的函數(shù)。
Parser類小結(jié)本章講解了Parser類的大部分實現(xiàn)，但是沒有講解Parser類如何分析模板內(nèi)容來確定生成哪個節(jié)點(diǎn)。這部分的內(nèi)容都是具體的實現(xiàn)細(xì)節(jié)，采用的分析技術(shù)主要有兩種：
字符串分析，看看字符串是否以某些特定模式開始。
token分析，利用了Python的tokenize模塊的功能來分析。
總結(jié)本文主要是分析了從模板文件到Template類實例的生成過程，大概是如下幾個步驟：
調(diào)用frender()函數(shù)讀取模板文件內(nèi)容，作為參數(shù)傳遞給Template類的初始化函數(shù)。
Template類調(diào)用Parser類將模板內(nèi)容解析成__template__()函數(shù)的定義代碼。
Template類調(diào)用Python的compile函數(shù)將生成的__template__()定義代碼進(jìn)行編譯。
Template類調(diào)用父類BaseTemplate類的初始化函數(shù)構(gòu)建__template__()函數(shù)的執(zhí)行環(huán)境，得到在指定環(huán)境下執(zhí)行的__template__()函數(shù)。
文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。
轉(zhuǎn)載請注明本文地址：http://systransis.cn/yun/37504.html
摘要：模板函數(shù)到底長什么樣下面我們就可以來看看模板函數(shù)到底長什么樣了。當(dāng)然，首先得創(chuàng)建一個模板文件?？偨Y(jié)通過打印中間結(jié)果和分析代碼，我們已經(jīng)大概知道了的模板是如何轉(zhuǎn)化成內(nèi)容的。下一篇文章會闡述模板的各種語法所對應(yīng)的動態(tài)函數(shù)內(nèi)容。 web.py模板的實現(xiàn)原理 web.py的模板實現(xiàn)利用了Python的可執(zhí)行對象的動態(tài)特性：根據(jù)模板內(nèi)容和渲染函數(shù)的參數(shù)創(chuàng)建一個函數(shù)，該函數(shù)執(zhí)行的時候會返回一個Te...
摘要：上一篇文章源碼分析模板說明了的模板的大致工作原理。本文重點(diǎn)講述模板支持的語法是如何轉(zhuǎn)換生成函數(shù)的。模板的名稱統(tǒng)一是。模板代碼斷行模板內(nèi)容函數(shù)內(nèi)容從結(jié)果來看，模板中的斷行只是為了不再結(jié)果中插入一個多余的換行符而已。 上一篇文章web.py源碼分析: 模板(1)說明了web.py的模板的大致工作原理。本文重點(diǎn)講述web.py模板支持的語法是如何轉(zhuǎn)換生成__template__函數(shù)的。 we...
摘要：本文主要分析的是庫的這個模塊中的代碼。將結(jié)果轉(zhuǎn)換成一個迭代器。函數(shù)函數(shù)的定義如下位置位置位置該函數(shù)的參數(shù)中就是，是路由映射表則是，是本次請求路徑。位置，如果是其他情況，比如直接指定一個類對象作為處理對象。 本文主要分析的是web.py庫的application.py這個模塊中的代碼?？偟膩碚f，這個模塊主要實現(xiàn)了WSGI兼容的接口，以便應(yīng)用程序能夠被WSGI應(yīng)用服務(wù)器調(diào)用。WSGI是We...
摘要：前言在文章基于環(huán)境搭建框架方法介紹中介紹了客戶端和服務(wù)器的交互過程，服務(wù)器接收客戶端的請求后，由應(yīng)用服務(wù)器對瀏覽器的請求進(jìn)行處理，將生成的響應(yīng)傳遞給服務(wù)器，再由服務(wù)器返回給客戶端。 前言 在文章《基于Linux環(huán)境搭建Nginx+uWSGI+Python框架方法介紹》中介紹了客戶端和Web服務(wù)器的交互過程，Web服務(wù)器接收客戶端的請求后，由Web應(yīng)用服務(wù)器對瀏覽器的請求進(jìn)行處理，將生成...
摘要：是應(yīng)用性能管理監(jiān)控解決方案提供商。目錄是列出的命令腳本所在目錄。包含文件如下的函數(shù)是命令執(zhí)行的入口。而對于硬件信息的檢測則由進(jìn)行。文檔地址源碼仔細(xì)看下去，太復(fù)雜了。下一篇再分析一個請求到結(jié)束探針工作的完整過程吧。 Newrelic 是APM（Application Performance Management）（應(yīng)用性能管理/監(jiān)控）解決方案提供商。項目中，通常用它來追蹤應(yīng)用的性能。最近...
閱讀 3243·2023-04-26 01:30
閱讀 700·2021-11-08 13:15
閱讀 1842·2021-09-24 10:35
閱讀 1037·2021-09-22 15:41
閱讀 1952·2019-08-30 15:44
閱讀 625·2019-08-30 13:22
閱讀 1031·2019-08-30 13:06
閱讀 1230·2019-08-29 13:22
