一、技術背景
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 内嵌解釋器
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)
}
}
2.1.2 動态擴充架構
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)
}
2.1.3 指令行解釋器
Yaegi提供了一個指令行工具，實作了 讀取-執行-顯示 的循環。
$ yaegi
> 1 + 2
3
> import "fmt"
> fmt.Println("Hello World")
Hello World
>
2.2 資料互動
資料互動方式比較多，需要注意的是從解釋器内部傳回的資料都是
reflect.Value
類型，擷取其實際的值需要類型轉換。
2.2.1 資料輸入
可以有（但不限于）下述四種方法：
- 通過 os.Args 傳入資料
- 通過 環境變量 傳入資料
- 通過 指派語句 傳入資料
- 通過 函數調用 傳入資料
下面是我自己寫的代碼示例：
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
}
}
2.1.2 資料輸出
從解釋器擷取資料，實際上是擷取全局變量的值，可以通過下述方法：
- Eval 方法直接擷取
- 通過函數調用擷取
- Global 方法擷取所有全局變量
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）的能力。基于抽象文法樹實作腳本解釋器，就容易很多。
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
在計算機科學中，抽象文法樹（Abstract Syntax Tree，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: INT
11 . . . 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: INT
29 . . . . . 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: INT
47 . . . . . . . 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: INT
62 . . . . . . . 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代替）
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