Golang CEL-Go 使用指南

CEL (Common Expression Language) 是 Google 开发的一种非图灵完备的表达式语言，专门设计用于安全评估。cel-go 是 Go 语言的 CEL 实现，非常适合需要表达式求值的场景，如配置验证、策略引擎等。

基本使用

安装

go get github.com/google/cel-go/cel

简单示例

package main

import (
	"fmt"
	"log"

	"github.com/google/cel-go/cel"
	"github.com/google/cel-go/checker/decls"
	"google.golang.org/protobuf/reflect/protoreflect"
)

func main() {
	// 创建 CEL 环境
	env, err := cel.NewEnv(
		cel.Declarations(
			decls.NewVar("name", decls.String),
		),
	)
	if err != nil {
		log.Fatalf("环境创建失败: %v", err)
	}

	// 解析表达式
	ast, issues := env.Compile(`"Hello, " + name + "!"`)
	if issues != nil && issues.Err() != nil {
		log.Fatalf("编译错误: %v", issues.Err())
	}

	// 创建程序
	prg, err := env.Program(ast)
	if err != nil {
		log.Fatalf("程序创建失败: %v", err)
	}

	// 评估表达式
	out, _, err := prg.Eval(map[string]interface{}{
		"name": "World",
	})
	if err != nil {
		log.Fatalf("评估失败: %v", err)
	}

	fmt.Println(out) // 输出: "Hello, World!"
}

高级特性

自定义函数

func main() {
	// 定义自定义函数
	env, err := cel.NewEnv(
		cel.Declarations(
			decls.NewVar("input", decls.Int),
			decls.NewFunction("double",
				decls.NewOverload(
					"double_int",
					[]*exprpb.Type{decls.Int},
					decls.Int,
				),
			),
		),
		cel.Functions(
			&functions.Overload{
				Operator: "double_int",
				Unary: func(value ref.Val) ref.Val {
					if intVal, ok := value.Value().(int64); ok {
						return types.Int(2 * intVal)
					}
					return types.NewErr("无效的输入类型")
				},
			},
		),
	)
	
	// 使用自定义函数
	ast, _ := env.Compile(`double(input)`)
	prg, _ := env.Program(ast)
	out, _, _ := prg.Eval(map[string]interface{}{
		"input": 5,
	})
	fmt.Println(out) // 输出: 10
}

类型检查

func main() {
	env, _ := cel.NewEnv(
		cel.Declarations(
			decls.NewVar("user", decls.NewMapType(decls.String, decls.Dyn)),
	)

	// 类型安全的表达式
	ast, issues := env.Compile(`user.age > 18 && user.name.startsWith("A")`)
	if issues != nil {
		fmt.Printf("类型检查错误: %v\n", issues.Err())
		return
	}

	prg, _ := env.Program(ast)
	out, _, _ := prg.Eval(map[string]interface{}{
		"user": map[string]interface{}{
			"name": "Alice",
			"age":  25,
		},
	})
	fmt.Println(out) // 输出: true
}

性能优化

对于需要重复评估的表达式，可以预先编译：

func main() {
	env, _ := cel.NewEnv()
	ast, _ := env.Compile(`1 + 2 + 3`)

	// 预编译程序
	prg, _ := env.Program(ast,
		cel.EvalOptions(cel.OptOptimize),
	)

	// 多次评估
	for i := 0; i < 1000; i++ {
		out, _, _ := prg.Eval(nil)
		_ = out
	}
}

实际应用场景

1. 配置验证

func validateConfig(config map[string]interface{}, rule string) bool {
	env, _ := cel.NewEnv(
		cel.Declarations(
			decls.NewVar("config", decls.NewMapType(decls.String, decls.Dyn)),
		),
	)
	
	ast, issues := env.Compile(rule)
	if issues != nil {
		return false
	}
	
	prg, _ := env.Program(ast)
	out, _, _ := prg.Eval(map[string]interface{}{
		"config": config,
	})
	
	result, ok := out.Value().(bool)
	return ok && result
}

// 使用示例
config := map[string]interface{}{
	"timeout": 30,
	"retries": 3,
}
valid := validateConfig(config, `config.timeout > 0 && config.retries < 5`)

2. 策略引擎

type User struct {
	Role     string
	Region   string
	Disabled bool
}

func checkAccess(user User, resource string) bool {
	env, _ := cel.NewEnv(
		cel.Declarations(
			decls.NewVar("user", decls.NewObjectType("User")),
			decls.NewVar("resource", decls.String),
		),
		cel.Types(&User{}),
	)
	
	policy := `user.Role == 'admin' || 
	          (user.Role == 'editor' && !user.Disabled && resource.startsWith(user.Region))`
	
	ast, _ := env.Compile(policy)
	prg, _ := env.Program(ast)
	out, _, _ := prg.Eval(map[string]interface{}{
		"user":     user,
		"resource": resource,
	})
	
	result, _ := out.Value().(bool)
	return result
}

最佳实践

1. 重用环境：创建 CEL 环境开销较大，应尽量重用
2. 预编译：对频繁使用的表达式进行预编译
3. 限制复杂度：CEL 不是图灵完备的，但复杂表达式仍可能影响性能
4. 类型安全：尽可能声明变量类型，利用类型检查功能
5. 错误处理：总是检查编译和评估阶段的错误

CEL-Go 提供了安全、高效的表达式求值能力，非常适合策略引擎、配置验证、条件过滤等场景。它的非图灵完备性保证了评估过程的安全性和可预测性。