Golang 动态脚本调研详解_开发_开发者_运维开发者技术经验分享

一、技术背景

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, FreeBSDjs 和 MACOS
卸载限制，仅支持动态加载，不支持动态卸载。
不提供统一接口，只能通过反射处理Plugin内部的属性和函数。

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

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

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

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

Golang 动态脚本调研详解

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 - 抽象语法树

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

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

3.1.1 抽象语法树示例

我们取Gola开发者_Go培训ng语法的子集进行示例：一个简单的条件表达式

`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"
http://www.devze.com   .  .  .  .  }
   .  .  .  }
   .  .  .  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 动态脚本调研详解

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 basi编程cLit, 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.ParenjsExpr); ok {
		return runExpr(parenExpr.X)
	}
	return result
}

执行结果：

A==1 && (B>1 || C<1) => true

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

以上就是Golang 动态脚本调研详解的详细内容，更多关于Golang 动态脚本的资料请关注我们其它相关文章！

Golang 动态脚本调研详解

目录

一、技术背景

1.1 程序的动态链接技术

1.1.1 动态链接库

1.1.2 动态共享对象

1.1.3 非编译语言的动态技术

1.2 Golang 的动态技术

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

2.1 使用场景

2.1.1 内嵌解释器

2.1.2 动态扩展框架

2.1.3 命令行解释器

2.2 数据交互

2.2.1 数据输入

2.1.2 数据输出

三、实现原理

3.1 AST - 抽象语法树

3.1.1 抽象语法树示例

3.1.2 执行抽象语法树

精彩评论

关注公众号

热门标签

图文推荐

Golang 动态脚本调研详解

目录

一、技术背景

1.1 程序的动态链接技术

1.1.1 动态链接库

1.1.2 动态共享对象

1.1.3 非编译语言的动态技术

1.2 Golang 的动态技术

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

2.1 使用场景

2.1.1 内嵌解释器

2.1.2 动态扩展框架

2.1.3 命令行解释器

2.2 数据交互

2.2.1 数据输入

2.1.2 数据输出

三、实现原理

3.1 AST - 抽象语法树

3.1.1 抽象语法树示例

3.1.2 执行抽象语法树

更多 开发 相关资讯：

精彩评论

关注公众号

热门标签

图文推荐

更多开发相关资讯：