一、技术背景

1.1 程序的动态链接技术

在实际开发过程中，我们经常需要动态地更新程序的功能，或者在不变更程序主体文件的情况下添加或者更新程序模块。

1.1.1 动态链接库

首先最常见的是windows平台所支持的动态链接库（Dynamic Link Library），一般后缀名为.dll。其优势非常明显：

多个程序可以共享代码和数据。即多个程序加载同一个DLL文件。可以自然地将程序划分为若干个模块。每个模块输出为单独的DLL文件，由主程序加载执行。跨语言调用。由于DLL文件是语言无关的，一个DLL文件可以被多种编程语言加载执行。便于更新。在程序更新过程中，仅更新对应模块的DLL文件即可，无需重新部署整个程序。为热更新提供技术可能性。动态链接库可以通过编程手段实现加载和卸载，以此可以支持不重启程序的情况下更新模块。为程序提供编程接口。可以将自己程序的调用接口封装为DLL文件，供其他程序调用。

1.1.2 动态共享对象

在Linux平台，此项技术名为动态共享对象（dynamic shared objects），常见后缀名为.so。

动态共享对象除了上述“动态链接库”的优势之外，也能解决由于Linux的开放性带来的底层接口兼容问题。即通过动态共享对象封装操作系统底层接口，对外提供统一的调用接口，以供上层应用程序调用。相当于提供了一层兼容层。

1.1.3 非编译语言的动态技术

非编译语言，由于本身是通过源代码发布，所以实现动态加载程序模块或者更新模块，直接修改源代码即可。思路简单且容易实现。

1.2 Golang 的动态技术

Golang作为编译型的开发语言，本身并不支持通过源代码实现动态加载和更新。但Golang官方提供了Plugin技术，实现动态加载。

通过在编译时添加参数，将Go程序编译为 Plugin：

go build-buildmode=plugin

但是此技术在当前版本（1.19）局限性非常大。通过其文档 https://pkg.go.dev/plugin 可知：

平台限制，目前仅支持：Linux, FreeBSD 和 macOS卸载限制，仅支持动态加载，不支持动态卸载。不提供统一接口，只能通过反射处理Plugin内部的属性和函数。

并且上述问题，Golang官方并不打算解决……

二、Golang 的第三方解释器（Yaegi）

解释器一般只存在于脚本语言中，但是Traefik为了实现动态加载的插件功能，开发了一个Golang的解释器。提供了在运行时直接执行Golang源代码的能力。

参考项目：https://github.com/traefik/yaegi

2.1 使用场景

yaegi 项目官方推荐三种场景：

内嵌解释器动态扩展框架命令行解释器

并且官方针对上述三种场景，均给出了相应的示例：

2.1.1 内嵌解释器

packagemainimport("github.com/traefik/yaegi/interp""github.com/traefik/yaegi/stdlib")func main(){i:=interp.New(interp.Options{})i.Use(stdlib.Symbols)_,err:=i.Eval(`import "fmt"`)iferr!=nil{panic(err)}_,err=i.Eval(`fmt.Println("Hello Yaegi")`)iferr!=nil{panic(err)}}

2.1.2 动态扩展框架

packagemainimport"github.com/traefik/yaegi/interp"constsrc=`package foofunc Bar(s string) string { return s + "-Foo" }`func main(){i:=interp.New(interp.Options{})_,err:=i.Eval(src)iferr!=nil{panic(err)}v,err:=i.Eval("foo.Bar")iferr!=nil{panic(err)}bar:=v.Interface().(func(string)string)r:=bar("Kung")println(r)}

2.1.3 命令行解释器

Yaegi提供了一个命令行工具，实现了 读取-执行-显示 的循环。

$ yaegi>1+23>import"fmt">fmt.Println("Hello World")HelloWorld>

2.2 数据交互

数据交互方式比较多，需要注意的是从解释器内部返回的数据都是reflect.Value类型，获取其实际的值需要类型转换。

2.2.1 数据输入

可以有（但不限于）下述四种方法：

通过 os.Args 传入数据通过 环境变量 传入数据通过 赋值语句 传入数据通过 函数调用 传入数据

下面是我自己写的代码示例：

packagemainimport("fmt""github.com/traefik/yaegi/interp""github.com/traefik/yaegi/stdlib")func main(){{// 通过 os.Args 传入数据i:=interp.New(interp.Options{Args:[]string{"666"},})i.Use(stdlib.Symbols)i.Eval(`import "fmt"`)i.Eval(`import "os"`)i.Eval(`fmt.Printf("os.Args[0] --- %s\n", os.Args[0])`)// os.Args[0] --- 666}{// 通过 环境变量 传入数据i:=interp.New(interp.Options{Env:[]string{"inputEnv=666"},})i.Use(stdlib.Symbols)i.Eval(`import "fmt"`)i.Eval(`import "os"`)i.Eval(`fmt.Printf("os.Getenv(\"inputEnv\") --- %s\n", os.Getenv("inputEnv"))`)// os.Getenv("inputEnv") --- 666}{// 执行赋值语句传入数据i:=interp.New(interp.Options{})i.Use(stdlib.Symbols)i.Eval(`import "fmt"`)i.Eval(fmt.Sprintf("inputVar:=\"%s\"","666"))i.Eval(`fmt.Printf("inputVar --- %s\n", inputVar)`)// inputVar --- 666}{// 通过函数调用传递i:=interp.New(interp.Options{})i.Use(stdlib.Symbols)i.Eval(`import "fmt"`)i.Eval(`var data map[string]interface{}`)i.Eval(`func SetData(d map[string]interface{}){ data = d }`)f,_:=i.Eval("SetData")fun:=f.Interface().(func(map[string]interface{}))fun(map[string]interface{}{"data01":666,})i.Eval(`fmt.Printf("SetData --- %d\n", data["data01"])`)// SetData --- 666}}

2.1.2 数据输出

从解释器获取数据，实际上是获取全局变量的值，可以通过下述方法：

Eval 方法直接获取通过函数调用获取Global 方法获取所有全局变量packagemainimport("fmt""github.com/traefik/yaegi/interp""github.com/traefik/yaegi/stdlib")func main(){{// 通过 Eval 直接获取i:=interp.New(interp.Options{})i.Use(stdlib.Symbols)i.Eval(`data := 666`)v,_:=i.Eval("data")value:=v.Interface().(int)fmt.Printf("data = %d\n",value)// data = 666}{// 通过函数返回值获取i:=interp.New(interp.Options{})i.Use(stdlib.Symbols)i.Eval(`data := 666`)i.Eval(`func GetData() int {return data}`)f,_:=i.Eval("GetData")fun:=f.Interface().(func()int)fmt.Printf("data = %d\n",fun())// data = 666}{// 通过 Eval 直接获取i:=interp.New(interp.Options{})i.Use(stdlib.Symbols)i.Eval(`dataInt := 666`)i.Eval(`dataStr := "666"`)forname,v:=range i.Globals(){value:=v.Interface()switchvalue.(type){caseint:fmt.Printf("%s = %d\n",name,value)// dataInt = 666casestring:fmt.Printf("%s = %s\n",name,value)// dataStr = 666}}}}

三、实现原理

就解释器的实现原理，各个语言都大差不差。Golang由于其强大的基础库，直接提供了构建抽象语法树（Abstract Syntax Tree）的能力。基于抽象语法树实现脚本解释器，就容易很多。

3.1 AST - 抽象语法树

https://zh.m.wikipedia.org/zh-hans/%E6%8A%BD%E8%B1%A1%E8%AA%9E%E6%B3%95%E6%A8%B9

在计算机科学中，抽象语法树（AbstractSyntaxTree，AST），或简称语法树（Syntax tree），是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。

Golang 通过go/ast包（https://pkg.go.dev/go/ast），提供抽象语法树相关能力。

3.1.1 抽象语法树示例

我们取Golang语法的子集进行示例：一个简单的条件表达式

`A!=1 && (B>1 || (C<1 && A>2))`

抽象语法树长这样：

0*ast.BinaryExpr{1.X:*ast.BinaryExpr{2..X:*ast.Ident{3...NamePos:-4...Name:"A"5..}6..OpPos:-7..Op:!=8..Y:*ast.BasicLit{9...ValuePos:-10...Kind:INT11...Value:"1"12..}13.}14.OpPos:-15.Op:&&16.Y:*ast.ParenExpr{17..Lparen:-18..X:*ast.BinaryExpr{19...X:*ast.BinaryExpr{20....X:*ast.Ident{21.....NamePos:-22.....Name:"B"23....}24....OpPos:-25....Op:>26....Y:*ast.BasicLit{27.....ValuePos:-28.....Kind:INT29.....Value:"1"30....}31...}32...OpPos:-33...Op:||34...Y:*ast.ParenExpr{35....Lparen:-36....X:*ast.BinaryExpr{37.....X:*ast.BinaryExpr{38......X:*ast.Ident{39.......NamePos:-40.......Name:"C"41......}42......OpPos:-43......Op:<44......Y:*ast.BasicLit{45.......ValuePos:-46.......Kind:INT47.......Value:"1"48......}49.....}50.....OpPos:-51.....Op:&&52.....Y:*ast.BinaryExpr{53......X:*ast.Ident{54.......NamePos:-55.......Name:"A"56......}57......OpPos:-58......Op:>59......Y:*ast.BasicLit{60.......ValuePos:-61.......Kind:INT62.......Value:"2"63......}64.....}65....}66....Rparen:-67...}68..}69..Rparen:-70.}71}

图形表示：

3.1.2 执行抽象语法树

简要说明一下如果要执行抽象语法树，应该怎么做：

执行过程与程序执行过程相似。先遍历声明列表，将已声明的内容初始化到堆内存（可以使用字典代替）。深度优先遍历抽象语法树，处理遍历过程中遇到的抽象对象，比如（举例而已，实际可能有出入）：

初始化堆内存和执行栈。遍历声明部分，写入堆，等待调用。找到主函数声明，主函数入栈，遍历其函数体语句，逐语句进行深度优先遍历执行。遇到变量定义，则写入栈顶缓存。遇到函数调用，则函数入栈。从堆中寻找函数定义，遍历其函数体语句，递归执行语句。遇到变量使用，依次从下述位置获取值：栈顶缓存 -> 堆内存遇到表达式，递归执行表达式。函数体执行结束后出栈，出栈后将返回值写入栈顶缓存。上述递归过程完成，程序结束。

上述是简单的执行过程，并未处理特殊语法和语法糖，各个语言的语法定义均有不同，需要单独处理。比如，Golang支持的语法可以参考：https://pkg.go.dev/go/ast

若能对其中定义的所有语法进行处理，就可以实现golang的脚本解释器。

对于上面（3.1.1）的那个简单示例，可以通过下述代码直接执行：

（不处理函数，只处理括号和有限的操作符。也未定义执行栈，堆内存使用全局变量Args代替）

packagemainimport("fmt""go/ast""go/parser""go/token""strconv")varArgsmap[string]intfunc main(){{Args=map[string]int{"A":1,"B":2,"C":3}code:=`A==1 && (B>1 || C<1)`expr,_:=parser.ParseExpr(code)result:=runExpr(expr)fmt.Println(result)}{Args["A"]=3Args=map[string]int{"A":1,"B":2,"C":3}code:=`A!=1 && (B>1 || (C<1 && A>2))`expr,_:=parser.ParseExpr(code)result:=runExpr(expr)fmt.Println(result)}}// 执行表达式// 支持操作：>, <, ==, !=, &&, ||// 支持括号嵌套func runExpr(expr ast.Expr)interface{}{varresultinterface{}// 二元表达式ifbinaryExpr,ok:=expr.(*ast.BinaryExpr);ok{switchbinaryExpr.Op.String(){case"&&":x:=runExpr(binaryExpr.X)y:=runExpr(binaryExpr.Y)returnx.(bool)&&y.(bool)case"||":x:=runExpr(binaryExpr.X)y:=runExpr(binaryExpr.Y)returnx.(bool)||y.(bool)case">":x:=runExpr(binaryExpr.X)y:=runExpr(binaryExpr.Y)returnx.(int)>y.(int)case"<":x:=runExpr(binaryExpr.X)y:=runExpr(binaryExpr.Y)returnx.(int)<y.(int)case"==":x:=runExpr(binaryExpr.X)y:=runExpr(binaryExpr.Y)returnx.(int)==y.(int)case"!=":x:=runExpr(binaryExpr.X)y:=runExpr(binaryExpr.Y)returnx.(int)!=y.(int)}}// 基本类型值ifbasicLit,ok:=expr.(*ast.BasicLit);ok{switchbasicLit.Kind{casetoken.INT:v,_:=strconv.Atoi(basicLit.Value)returnv}}// 标识符ifident,ok:=expr.(*ast.Ident);ok{returnArgs[ident.Name]}// 括号表达式ifparenExpr,ok:=expr.(*ast.ParenExpr);ok{returnrunExpr(parenExpr.X)}returnresult}

执行结果：

A==1&&(B>1||C<1)=>trueA!=1&&(B>1||(C<1&&A>2))=>false