在实际开发过程中,我们经常需要动态地更新程序的功能,或者在不变更程序主体文件的情况下添加或者更新程序模块。
首先最常见的是windows平台所支持的动态链接库(Dynamic Link Library),一般后缀名为.dll
。其优势非常明显:
在Linux平台,此项技术名为动态共享对象(dynamic shared objects),常见后缀名为.so
。
动态共享对象除了上述“动态链接库”的优势之外,也能解决由于Linux的开放性带来的底层接口兼容问题。即通过动态共享对象封装操作系统底层接口,对外提供统一的调用接口,以供上层应用程序调用。相当于提供了一层兼容层。
非编译语言,由于本身是通过源代码发布,所以实现动态加载程序模块或者更新模块,直接修改源代码即可。思路简单且容易实现。
Golang作为编译型的开发语言,本身并不支持通过源代码实现动态加载和更新。但Golang官方提供了Plugin技术,实现动态加载。
通过在编译时添加参数,将Go程序编译为 Plugin:
go build -buildmode=plugin
但是此技术在当前版本(1.19)局限性非常大。通过其文档 http://pkg.go.dev/plugin 可知:
并且上述问题,Golang官方并不打算解决……
解释器一般只存在于脚本语言中,但是Traefik为了实现动态加载的插件功能,开发了一个Golang的解释器。提供了在运行时直接执行Golang源代码的能力。
参考项目:https://github.com/traefik/yaegi
yaegi 项目官方推荐三种场景:
并且官方针对上述三种场景,均给出了相应的示例:
package main import ( "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"`) if err != nil { panic(err) } _, err = i.Eval(`fmt.Println("Hello Yaegi")`) if err != nil { panic(err) } }
package main import "github.com/traefik/yaegi/interp" const src = `package foo func Bar(s string) string { return s + "-Foo" }` func main() { i := interp.New(interp.Options{}) _, err := i.Eval(src) if err != nil { panic(err) } v, err := i.Eval("foo.Bar") if err != nil { panic(err) } bar := v.Interface().(func(string) string) r := bar("Kung") println(r) }
Yaegi提供了一个命令行工具,实现了 读取-执行-显示 的循环。
$ yaegi > 1 + 2 3 > import "fmt" > fmt.Println("Hello World") Hello World >
数据交互方式比较多,需要注意的是从解释器内部返回的数据都是 reflect.Value
类型,获取其实际的值需要类型转换。
可以有(但不限于)下述四种方法:
下面是我自己写的代码示例:
package main import ( "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 } }
从解释器获取数据,实际上是获取全局变量的值,可以通过下述方法:
package main import ( "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"`) for name, v := range i.Globals() { value := v.Interface() switch value.(type) { case int: fmt.Printf("%s = %d\n", name, value) // dataInt = 666 case string: fmt.Printf("%s = %s\n", name, value) // dataStr = 666 } } } }
就解释器的实现原理,各个语言都大差不差。Golang由于其强大的基础库,直接提供了构建抽象语法树(Abstract Syntax Tree)的能力。基于抽象语法树实现脚本解释器,就容易很多。
在计算机科学中,抽象语法树(Abstract Syntax Tree,AST),或简称语法树(Syntax tree),是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构,树上的每个节点都表示源代码中的一种结构。
Golang 通过 go/ast
包(http://pkg.go.dev/go/ast),提供抽象语法树相关能力。
我们取Golang语法的子集进行示例:一个简单的条件表达式
`A!=1 && (B>1 || (C<1 && A>2))`
抽象语法树长这样:
*ast.BinaryExpr { . X: *ast.BinaryExpr { . . X: *ast.Ident { . . . NamePos: - . . . Name: "A" . . } . . OpPos: - . . Op: != . . Y: *ast.BasicLit { . . . ValuePos: - . . . Kind: INT . . . Value: "1" . . } . } . OpPos: - . Op: && . Y: *ast.ParenExpr { . . Lparen: - . . X: *ast.BinaryExpr { . . . X: *ast.BinaryExpr { . . . . X: *ast.Ident { . . . . . NamePos: - . . . . . Name: "B" . . . . } . . . . OpPos: - . . . . Op: > . . . . Y: *ast.BasicLit { . . . . . ValuePos: - . . . . . Kind: INT . . . . . Value: "1" . . . . } . . . } . . . OpPos: - . . . Op: || . . . Y: *ast.ParenExpr { . . . . Lparen: - . . . . X: *ast.BinaryExpr { . . . . . X: *ast.BinaryExpr { . . . . . . X: *ast.Ident { . . . . . . . NamePos: - . . . . . . . Name: "C" . . . . . . } . . . . . . OpPos: - . . . . . . Op: < . . . . . . Y: *ast.BasicLit { . . . . . . . ValuePos: - . . . . . . . Kind: INT . . . . . . . Value: "1" . . . . . . } . . . . . } . . . . . OpPos: - . . . . . Op: && . . . . . Y: *ast.BinaryExpr { . . . . . . X: *ast.Ident { . . . . . . . NamePos: - . . . . . . . Name: "A" . . . . . . } . . . . . . OpPos: - . . . . . . Op: > . . . . . . Y: *ast.BasicLit { . . . . . . . ValuePos: - . . . . . . . Kind: INT . . . . . . . Value: "2" . . . . . . } . . . . . } . . . . } . . . . Rparen: - . . . } . . } . . Rparen: - . } }
图形表示:
简要说明一下如果要执行抽象语法树,应该怎么做:
执行过程与程序执行过程相似。先遍历声明列表,将已声明的内容初始化到堆内存(可以使用字典代替)。深度优先遍历抽象语法树,处理遍历过程中遇到的抽象对象,比如(举例而已,实际可能有出入):
遇到变量定义,则写入栈顶缓存。
遇到函数调用,则函数入栈。从堆中寻找函数定义,遍历其函数体语句,递归执行语句。
遇到变量使用,依次从下述位置获取值:栈顶缓存 -> 堆内存
遇到表达式,递归执行表达式。
函数体执行结束后出栈,出栈后将返回值写入栈顶缓存。
上述是简单的执行过程,并未处理特殊语法和语法糖,各个语言的语法定义均有不同,需要单独处理。比如,Golang支持的语法可以参考:http://pkg.go.dev/go/ast
若能对其中定义的所有语法进行处理,就可以实现golang的脚本解释器。
对于上面(3.1.1)的那个简单示例,可以通过下述代码直接执行:
(不处理函数,只处理括号和有限的操作符。也未定义执行栈,堆内存使用全局变量Args代替)
package main import ( "fmt" "go/ast" "go/parser" "go/token" "strconv" ) var Args map[string]int func 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"] = 3 Args = 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{} { var result interface{} // 二元表达式 if binaryExpr, ok := expr.(*ast.BinaryExpr); ok { switch binaryExpr.Op.String() { case "&&": x := runExpr(binaryExpr.X) y := runExpr(binaryExpr.Y) return x.(bool) && y.(bool) case "||": x := runExpr(binaryExpr.X) y := runExpr(binaryExpr.Y) return x.(bool) || y.(bool) case ">": x := runExpr(binaryExpr.X) y := runExpr(binaryExpr.Y) return x.(int) > y.(int) case "<": x := runExpr(binaryExpr.X) y := runExpr(binaryExpr.Y) return x.(int) < y.(int) case "==": x := runExpr(binaryExpr.X) y := runExpr(binaryExpr.Y) return x.(int) == y.(int) case "!=": x := runExpr(binaryExpr.X) y := runExpr(binaryExpr.Y) return x.(int) != y.(int) } } // 基本类型值 if basicLit, ok := expr.(*ast.BasicLit); ok { switch basicLit.Kind { case token.INT: v, _ := strconv.Atoi(basicLit.Value) return v } } // 标识符 if ident, ok := expr.(*ast.Ident); ok { return Args[ident.Name] } // 括号表达式 if parenExpr, ok := expr.(*ast.ParenExpr); ok { return runExpr(parenExpr.X) } return result }
执行结果:
A==1 && (B>1 || C<1) => true
A!=1 && (B>1 || (C<1 && A>2)) => false