Golang 动态脚本调研详解

09-02 166阅读 0评论

一、技术背景

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

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

在计算机科学中,抽象语法树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))` 

抽象语法树长这样:

   *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 动态脚本调研详解

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

以上就是Golang 动态脚本调研详解的详细内容,更多关于Golang 动态脚本的资料请关注云初冀北其它相关文章!

免责声明
本站提供的资源,都来自网络,版权争议与本站无关,所有内容及软件的文章仅限用于学习和研究目的。不得将上述内容用于商业或者非法用途,否则,一切后果请用户自负,我们不保证内容的长久可用性,通过使用本站内容随之而来的风险与本站无关,您必须在下载后的24个小时之内,从您的电脑/手机中彻底删除上述内容。如果您喜欢该程序,请支持正版软件,购买注册,得到更好的正版服务。侵删请致信E-mail:goliszhou@gmail.com
$

发表评论

表情:
评论列表 (暂无评论,166人围观)

还没有评论,来说两句吧...