Golang template 包基本原理分析_Golang

template 概述

最近在做脚手架相关的内容, 研究了一下 Go 的 text/template 包, 接下来跟大家分享下 template 的基本原理.

在 Golang 的标准库中, 有两个和 template 有关的包, 一个是 html/template, 另外一个是 text/template, 这两个包的主要区别是 html 版本加入了很多对 js字符串和 html标签的处理, 下面我们主要用 text/template 作为案例说明.

解析流程

首先, 无论是使用 template.Parse() 还是 template.New() 都会创建一个 *Template 对象, 用来管理整个处理流程.

模板处理主要分为两个阶段, 第一个阶段是parse 阶段, 在这个阶段, 会把读入的数据, 不论是从文件读入还是直接从字符串读取的内容, 统一解析成节点树, 第二个阶段是 execute 阶段, 在这个阶段, 会把传进来的变量解析到节点树上, 生成最终的输出流, 然后写入到 io.Writer 中.

Golang template 包基本原理分析

下边我们看一段简单的使用template 的代码

				?

									package main

									import (

									   "os"

									   "text/template"

									)

									var templateStr = `

									package main

									func main() {

									    fmt.Println("Hello, {{.Name}}!")

									}

									`

									func main() {

									   // 创建template对象

									   t := template.New("demo")

									   // 解析模板内容

									   parse, err := t.Parse(templateStr)

									   if err != nil {

									      panic(err)

									   }

									   // 执行解析

									   data := map[string]string{"Name": "World"}

									   err = parse.Execute(os.Stdout, data)

									   if err != nil {

									      panic(err)

									   }

									}

运行后可以看到输出:

				?

									package main

									func main() {

									    fmt.Println("Hello, World!")

									}

接下来我们就一起来分析下执行过程:

template.New 创建了一个template对象

				?

									// src/text/template/template.go

									type Template struct {

									   name string

									   *parse.Tree

									   *common

									   leftDelim  string

									   rightDelim string

									}

Parse阶段

其中 *parse.Tree 只在 html/template 中使用, 表示解析完成的模板, *common 里包含了解析过程中所有输入的模板, 用一个 map 存储, 之所以使用map, 是因为 template 支持 {{define block}} 这种嵌套模板, 每一个模板快都会被解析成一个 Template对象, 然后放到这个map里, 供模板之间引用. 下面我们重点看下, 每个模板解析完之后生成的 parse.Tree.

Golang template 包基本原理分析

上边的代码生成的模板对象 t 包含的map只有一个元素, 元素的 Root属性(即parse之后生成的 parse.Tree), 会有三个节点.

Golang template 包基本原理分析

其中 TextNode 直接存储了文本, ActionNode 会解析出 .Name 变量, 将文本字符串解析成为 parse.Tree 对象之后, Parse阶段就执行结束了, 接下来就是 Execute 阶段.

Execute阶段

				?

									// src/text/template/exec.go

									func (t *Template) Execute(wr io.Writer, data any) error {

									   return t.execute(wr, data)

									}

									func (t *Template) execute(wr io.Writer, data any) (err error) {

									   defer errRecover(&err)

									   // 使用反射解析传入的参数

									   value, ok := data.(reflect.Value)

									   ...

									   state := &state{

									      tmpl: t,

									      wr:   wr,

									      vars: []variable{{"$", value}},

									   }

									   ...

									   // 遍历节点

									   state.walk(value, t.Root)

									   return

									}

Execute阶段开始的时候, 会先反射传入的 data, 用来解析模板内的变量, 接下来遍历模板的Root 也就是从节点树的根开始遍历处理每个节点, 这里使用了递归的方式.

				?

									// src/text/template/exec.go

									func (s *state) walk(dot reflect.Value, node parse.Node) {

									   s.at(node)

									   switch node := node.(type) {

									   case *parse.ActionNode:

									      val := s.evalPipeline(dot, node.Pipe)

									      if len(node.Pipe.Decl) == 0 {

									         s.printValue(node, val)

									      }

									   ...

									   case *parse.ListNode:

									       // 循环遍历节点, 递归 

									      for _, node := range node.Nodes {

									         s.walk(dot, node)

									      }

									   ...

									   case *parse.TextNode:

									      if _, err := s.wr.Write(node.Text); err != nil {

									         s.writeError(err)

									      }

									   ...

									}

我们看下 ActionNode 和 TextNode 的处理

ActionNode ActionNode 在Parse阶段生成语法树, 在Execute阶段分为两步处理, 第一步, 是解析语法树, 把对应的变量替换成实际的值, 对应方法evalPipeline(), 第二步是把生成的结果输出, 对应了代码printValue()
TextNode TextNode 就很简单了, 直接把Node存储的文本原封不动的打印, 直接使用了 Write()方法写入

节点遍历完成之后, 所有的文本已经都输出到 io.Writer 中, 模板执行结束.

至此, 整个流程完成.