資訊專欄INFORMATION COLUMN
摘要：前兩篇文章主要說明了的模板系統將模板文件處理后得到的結果函數。生成函數的代碼這個是模板生成過程中最長最復雜的一段，會應用到的分析功能以及動態編譯功能。參數都是一個，表示還未解析的模板內容。
前兩篇文章主要說明了web.py的模板系統將模板文件處理后得到的結果：__template__()函數。本文主要講述模板文件是如何變成__template__()函數的。
Render和frender一般來說，更常用的是Render類，該類會處理整個目錄下的模板，還支持緩存和嵌套模板。不過這些其實都和模板本身的解析基本沒關系，以后再說明這個類的實現和用途。這里我們使用frender()函數：
def frender(path, **keywords):
"""Creates a template from the given file path.
"""
return Template(open(path).read(), filename=path, **keywords)
這個函數相當簡單，只作了一鍵事情，就是讀取模板文件內容，然后交給Template類處理，并且返回一個Template類實例。從這里也可以看出，整個模板的解析，只和Template類有關，frender是來打雜的。
Template類 Template實例的效果當我們根據一個模板內容創建一個Template類實例t后，我們可以調用該實例，這相當于調用模板對應的__template__()函數，得到的結果是一個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實例化過程是把模板轉換成HTML內容的實質性步驟，不過這個過程比較復雜。但是，概括的來講，這個過程和Template的__init__()函數中的步驟差不都差不多。
# Template類的__init__()函數
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)
首先把，參數里除了text以外的參數忽略掉，然后來看下對text的處理過程（text就是模板的內容）。整個過程概括的說有如下步驟：
對text作歸一化處理：text = Template.normalize_text(text)， 主要換行符統一成 ，刪除BOM字符串，將$替換成$$，這個就是簡單的字符串處理。
編譯模板得到編譯后的Python字節碼code：code = self.compile_template(text, filename)，code就是之前已經提到過的__template__()函數。
調用父類(BaseTemplate)的__init__()函數：創建__template__()函數的執行環境，并且實現可調用功能。
其他沒有說明的代碼，暫時都可以忽略，不會影響你理解Template的實例化過程。從上面的步驟可以看出，Template實例化的過程主要有兩個：生成__template__()函數的代碼并編譯，以及創建__template__()函數的執行環境。
生成__template__()函數的代碼這個是模板生成過程中最長最復雜的一段，會應用到Python的token分析功能以及動態編譯功能。還記得第一篇里，我們搭建實驗環境的時候，修改了web.py源碼，在一個地方插入了一行打印語句么？沒錯，就是這個compile_template()函數，我們現在來看看它是如何生成__template__()函數的代碼的。
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 # 上次增加的打印語句
...
很明顯，第一行的調用就生成了__template__()函數的代碼。我們繼續看：
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
這兩個函數配合起來使用，意思就是：創建一個沒有擴展的Parser實例，用該實例解析模板內容得到rootnode，調用rootnode的emit()函數得到最終的代碼（__template__()函數）。所以，問題的關鍵由轉到了Parser類上。
Parser類初探Parser類的parse函數解析模板內容，然后返回一些節點結構，這種節點結構的emit方法會產生實際的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類的兩個方法，初始化函數沒啥好說的，parse函數則是說明了模板解析的最頂層邏輯：
先解析def with這行。
然后解析剩余部分。
最后返回一個DefwithNode實例。
這里不打算細說整個解析過程（后面專門說），反正知道了Parser類的parse函數可以返回一個DefwithNode實例，且調用其emit()方法后能生成最終的代碼即可。
編譯__template__()函數的代碼在compile_template方法得到模板對應的代碼后，就要對這個代碼進行編譯，生成Python的字節碼：
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類實例化過程的第二個步驟：得到了編譯后的模板函數代碼。
BaseTemplate接下來就是要調用父類，也就是BaseTemplate類，的初始化方法了：
BaseTemplate.__init__(self, code=code, filename=filename, filter=filter, globals=globals, builtins=builtins)
該方法接受的參數中，code就是上面編譯出來的字節碼，globals和builtins是用來構建__template__()函數的運行環境的，記得在web.py的文檔中有說可以修改這兩個的地方么？忘記的話，傳送門。filter函數是過濾函數，用來處理生成的HTML內容。
globals和builtins如果你的代碼中不指定，默認情況下，globals是空的，builtins則包含如下內容：
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的全局內置函數的一個子集，你在模板中可以直接使用。
BaseTemplate的初始化這個初始化過程，我們直接看代碼(只列出相關函數）：
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
)
初始化的時候，主要的工作是調用self.t = self._compile(code)。_compile()方法先使用make_env()方法構造一個函數運行環境env，里面包含了__template__()函數會用到的對象，包括默認的內置函數，以及TemplateResult等。然后，調用exec(code, env)在env環境下執行__template__()函數的定義，最后返回的env["__template"]就是在env環境下執行的__template__()函數。
注意:*在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
如果以元組作為參數，則有如下兩個形式：
exec (code, globals) exec (code, globals, locals)
globals字典中可以插入__builtins__ 對象來設置內置對象的引用，比如上面的make_env()函數。
Parser類現在可以來看Parser類是如何解析模板，并生成特定的節點結構的。還是從parse函數開始：
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)
首先調用read_defwith()方法，將$def with (name)這行分離出來，剩余的都交給read_suite()方法去解析，最后再實例化一個DefwithNode作為解析結果。整個解析的主要工作是由read_suite()方法完成的。
Parser類的實現慣例 解析函數Parser類里面實現了如下這些方法：
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
這些方法的參數和返回值都遵循同一個模式，先知道一下有助于閱讀代碼。
每個方法都負責解析特定的內容（方法名可以體現），有的方法內部會調用其他的方法。
參數都是一個text，表示還未解析的模板內容。
返回值都是含有兩個元素的元組，第一個元素是該函數解析的結果（字符串或者某個類實例），第二個元素是該函數處理過后還剩余的模板內容（給下個函數去解析）。
從這個慣例可以看出，整個模板解析的思想是：從模板內容頭部開始，一點一點的讀取，一旦所讀取的內容可以解析就進行解析，剩余的內容再繼續這么處理。
另外，這些解析函數還有包含關系，有一些是處理整塊內容的函數，有一些則是處理一行，還有的是處理一個單詞，這也就形成了一個調用關系：粗粒度的函數調用細粒度的解析函數。如下圖所示：
解析節點上一小節提到了，解析函數返回值中的第一個一般都是解析好的節點類實例。那么什么是解析節點呢？解析節點其實就是一些類，這些類都實現了emit()函數，當調用emit()時，就會產生對應的代碼字符串。先來看下有哪些解析節點吧：
-- TextNode ExpressoinNode LineNode VarNode StatementNode AssignmentNode BlockNode IfNode, ElseNode, ElifNode ForNode CodeNode DefNode SuiteNode DefwithNode
這些節點的功能基本上從類名稱就可以看出來，有些節點只是其他節點的包裝（比如LineNode），有一些則需要處理比較復雜的情況（比如ForNode）。但是這些節點作的事情都是可以概括為：處理初始化參數以便在調用emit方法的時候能產生正確的代碼。來看兩個例子：
AssignmentNode模板內容
$def with (name) $ b = name
函數內容
def __template__ (name):
__lineoffset__ = -4
loop = ForLoop()
self = TemplateResult(); extend_ = self.extend
b = name
return self
我們知道當解析到$ b = name這行時，會生成一個AssignmentNode，調用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的模板系統就是這樣針對每個節點調用emit()方法來生產最終的代碼的。
ForNode我們再來看復雜一點的ForNode節點。
模板內容
$def with (name_list)
$for name in name_list:
$name
函數內容
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中調用創建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"
"])
創建ForNode節點實例時，是把第一行的循環控制語句和其他的循環內部代碼分別作為兩個參數傳遞給ForNode的初始化函數。ForNode的主要工作是解析第一個參數，轉換為loop.setup()這樣的代碼（為了能夠在模板中支持loop關鍵字）。然后，調用父類BlockNode的初始化函數，主要作用是調用Parser類的read_suite()方法解析循環內部的代碼，因為我們在循環內部也會使用模板語法（就像上面例子中的$name 被轉換成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內部就是一個列表，保存了所有子節點，調用SuiteNode的emit()方法時，就是依次調用子節點的emit()方法，然后連接成一個字符串：
def emit(self, indent, text_indent=""):
return "
" + "".join([s.emit(indent, text_indent) for s in self.sections])
DefwithNode
DefwithNode作為根節點，做了兩個事情：
生成__template__()函數的框架。
調用suite.emit()生成其余的代碼，并且拼接得到一個完整的函數。
Parser類小結本章講解了Parser類的大部分實現，但是沒有講解Parser類如何分析模板內容來確定生成哪個節點。這部分的內容都是具體的實現細節，采用的分析技術主要有兩種：
字符串分析，看看字符串是否以某些特定模式開始。
token分析，利用了Python的tokenize模塊的功能來分析。
總結本文主要是分析了從模板文件到Template類實例的生成過程，大概是如下幾個步驟：
調用frender()函數讀取模板文件內容，作為參數傳遞給Template類的初始化函數。
Template類調用Parser類將模板內容解析成__template__()函數的定義代碼。
Template類調用Python的compile函數將生成的__template__()定義代碼進行編譯。
Template類調用父類BaseTemplate類的初始化函數構建__template__()函數的執行環境，得到在指定環境下執行的__template__()函數。
文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。
轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/37504.html
摘要：模板函數到底長什么樣下面我們就可以來看看模板函數到底長什么樣了。當然，首先得創建一個模板文件。總結通過打印中間結果和分析代碼，我們已經大概知道了的模板是如何轉化成內容的。下一篇文章會闡述模板的各種語法所對應的動態函數內容。 web.py模板的實現原理 web.py的模板實現利用了Python的可執行對象的動態特性：根據模板內容和渲染函數的參數創建一個函數，該函數執行的時候會返回一個Te...
摘要：上一篇文章源碼分析模板說明了的模板的大致工作原理。本文重點講述模板支持的語法是如何轉換生成函數的。模板的名稱統一是。模板代碼斷行模板內容函數內容從結果來看，模板中的斷行只是為了不再結果中插入一個多余的換行符而已。 上一篇文章web.py源碼分析: 模板(1)說明了web.py的模板的大致工作原理。本文重點講述web.py模板支持的語法是如何轉換生成__template__函數的。 we...
摘要：本文主要分析的是庫的這個模塊中的代碼。將結果轉換成一個迭代器。函數函數的定義如下位置位置位置該函數的參數中就是，是路由映射表則是，是本次請求路徑。位置，如果是其他情況，比如直接指定一個類對象作為處理對象。 本文主要分析的是web.py庫的application.py這個模塊中的代碼。總的來說，這個模塊主要實現了WSGI兼容的接口，以便應用程序能夠被WSGI應用服務器調用。WSGI是We...
摘要：前言在文章基于環境搭建框架方法介紹中介紹了客戶端和服務器的交互過程，服務器接收客戶端的請求后，由應用服務器對瀏覽器的請求進行處理，將生成的響應傳遞給服務器，再由服務器返回給客戶端。 前言 在文章《基于Linux環境搭建Nginx+uWSGI+Python框架方法介紹》中介紹了客戶端和Web服務器的交互過程，Web服務器接收客戶端的請求后，由Web應用服務器對瀏覽器的請求進行處理，將生成...
摘要：是應用性能管理監控解決方案提供商。目錄是列出的命令腳本所在目錄。包含文件如下的函數是命令執行的入口。而對于硬件信息的檢測則由進行。文檔地址源碼仔細看下去，太復雜了。下一篇再分析一個請求到結束探針工作的完整過程吧。 Newrelic 是APM（Application Performance Management）（應用性能管理/監控）解決方案提供商。項目中，通常用它來追蹤應用的性能。最近...
閱讀 3198·2023-04-26 01:30
閱讀 665·2021-11-08 13:15
閱讀 1774·2021-09-24 10:35
閱讀 999·2021-09-22 15:41
閱讀 1930·2019-08-30 15:44
閱讀 593·2019-08-30 13:22
閱讀 1005·2019-08-30 13:06
閱讀 1197·2019-08-29 13:22
