iis服务器助手广告广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > GO >Golang 动态脚本调研详解
  • 189

0
分享到

Golang 动态脚本调研详解

2024-04-02 19:04:59 189人浏览 独家记忆
摘要

目录一、技术背景1.1 程序的动态链接技术1.1.1 动态链接库1.1.2 动态共享对象1.1.3 非编译语言的动态技术1.2 golang 的动态技术二、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, 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 - 抽象语法树

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

抽象语法树长这样：

   *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: -
   .  }
   }

图形表示：

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 动态脚本的资料请关注编程网其它相关文章！

您可能感兴趣的文档:
点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Golang 动态脚本调研详解

本文链接: https://www.lsjlt.com/news/121094.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • Golang 动态脚本调研详解
    目录一、技术背景1.1 程序的动态链接技术1.1.1 动态链接库1.1.2 动态共享对象1.1.3 非编译语言的动态技术1.2 Golang 的动态技术二、Golang 的第三方解释...
    99+
    2024-04-02
  • Java详解ScriptEngine接口动态执行JS脚本
    目录简介Eval(String script)描述实例代码Put() and Get()描述实例代码CompiledScript描述实例代码Bindings描述实例代码大多的方法描述...
    99+
    2022-11-13
    Java ScriptEngine Java 动态执行JavaScript脚本
  • SpringBoot整合Groovy脚本实现动态编程详解
    目录Groovy简介应用场景集成与使用第一步、与SpringBoot集成1、pom.xml文件如下：第二步、写出Groovy版本的“Hello World”1...
    99+
    2024-04-02
  • Java动态脚本Groovy
    目录1.Groovy特性 2.核心涉及 3.Java与Groovy转换 第一步：引入Groovy依赖 第二步：创建interface接口声明方法 第三步：在resources目录下创...
    99+
    2024-04-02
  • c#动态执行脚本的3种方式详解
    目录1.使用Roslyn编译器2.使用IronPython或IronRuby3.使用JavaScript引擎在C#中，可以使用一些第三方库或内置类库实现动态执行脚本的功能。以下是几个...
    99+
    2023-05-14
    c#动态执行脚本 c#动态执行
  • Golang使用反射的动态方法调用详解
    Go是一种静态类型的语言，提供了大量的安全性和性能。静态类型的好处之一是，编译器可以在编译时捕获错误，防止在运行时发生。 在Go中，方法是用语法func(receiverName r...
    99+
    2023-03-14
    Golang反射动态方法调用 Golang反射动态方法 Golang反射
  • golang怎么调用python脚本
    在Golang中调用Python脚本可以使用os/exec包来执行外部命令。下面是一个简单的示例代码：gopackage maini...
    99+
    2023-10-20
    golang python
  • golang 动态调用方法
    Golang是一门非常强大的语言，可以用于构建各种类型的应用，从命令行工具到Web应用和分布式系统，甚至还可以用于机器学习和数据科学等领域。在Golang中，可以通过反射来动态地调用方法。反射是一种能够在运行时检查程序类型、变量类型和方法的...
    99+
    2023-05-14
  • Golang 字符串修改详解：动态调整和可变性
    golang 中的字符串虽然不可变，但可通过以下技术动态修改：使用字符串连接符连接字符串。使用字符串格式化创建新字符串。修改字符串底层字节切片。使用第三方库提供的可变字符串类型。 Go...
    99+
    2024-04-08
    字符串 golang
  • 详解Struts2动态方法调用
    　动态方法就是一个Action对应多个请求，减少Action的数量1、指定method属性<action name="addAction" method="add" class="com.venn.action.HelloWorldA...
    99+
    2023-05-31
    struts2 用 st
  • SpringBoot动态Feign服务调用详解
    目录1.Feign传统方式的不足2.动态Feign2.1.服务生产者2.2.动态Feign2.3.服务消费者3.总结1.Feign传统方式的不足 ①.在微服务架构中,当我们使用Fei...
    99+
    2022-12-21
    SpringBoot动态Feign SpringBoot动态Feign服务调用
  • Shell 脚本详解
    简介 shell ：蛋、壳。shell脚本是在操作系统外，可以直接调用系统内核命令的一个脚本语言。 shell脚本可以分为两大类组成： 1.命令行 （系统命令行）2.脚本语法 （编程语言的基本语法） 命令行：可以直接和系统内核进行交换使用 ...
    99+
    2023-08-19
    linux bash 服务器
  • Golang动态调用方法小结
    main.go package main import ( "lenu/call" "reflect" ) type FuncCollection map[str...
    99+
    2024-04-02
  • java 内嵌Groovy动态脚本操作
    固定的策略有时候还是无法满足千变万化的需求变动，一方面需要支持特定的用户需求，另一方面又得尽可能的复用代码，避免重复开发，这就需要将这部分的特殊的需求剥离出来，采用动态配置规则的方式...
    99+
    2024-04-02
  • golang调用shell脚本的方法是什么
    在Go语言中，可以使用os/exec包来调用shell脚本。 下面是一个示例代码： package main import ( ...
    99+
    2024-02-29
    golang shell
  • Golang动态调用方法是什么
    Golang动态调用方法是什么，很多新手对此不是很清楚，为了帮助大家解决这个难题，下面小编将为大家详细讲解，有这方面需求的人可以来学习下，希望你能有所收获。main.gopackage main import ...
    99+
    2023-06-22
  • linux shell脚本详解
    shell 1. 基础 # shell的执行方式：- 路径方式 ：必须赋予权限- source 立即执行，不需要权限- bash 执行新建一个文件，扩展名为sh（sh代表shell），输入一些代码：...
    99+
    2023-09-08
    linux bash 运维
  • windows使用netsh设置静态&动态ip的脚本
    使用netsh设置静态ip地址： 复制代码代码如下: @echo off netsh interface ip set address "本地连接" static 172.24.83.239 255.255.255.0 ...
    99+
    2023-05-29
    静态ip 动态ip 脚本 windows netsh 静态
  • Java动态脚本Groovy获取Bean技巧
    目录一、使用BeanFactoryPostProcessor注入Bean： 第一步：创建实现SpringUtils 接口工具（组件）来获取spring bean 第二步：创建Groo...
    99+
    2024-04-02
  • 深入研究：go和golang的差异详解
    深入探究：Go 和 Golang 之间的差异随着现代技术的飞速发展和应用需求的不断增长，编程语言成为了开发者们必备的工具。近年来，Go（也被称为Golang）在编程界引起了广泛的关注和讨论。然而，对于初学者和有经验的开发者来说，Go 和 G...
    99+
    2023-12-29
    差异比较：go vs golang
软考高级职称资格查询
iis服务器助手广告
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作