common expression language 自定义函数

作者: mace3170 | 来源:发表于2023-11-11 23:42 被阅读0次

字符与字符串处理
thinkphp 3.1.3 自定义函数和自定义CSS和js路径
EL表达式与JSTL
CLR IL JIT
CI 中自定义函数
Streaminsets
Web 基础16 JSP之EL 入门
生信流程工具-CWL
Fin-Expr: 一个新造的Java实现的表达式计算轮子
Test Spring el with ExpressionPa

📜 目录

👋 背景
💻 简单了解
✨ 原理说明
✨ 快速操作
💪 解决问题
🦾 内置能力
💪 自定义函数
🧠 总结
🤩 参考

👋 背景

CEL 是Google 提供的通用的表达式解析的语法，cel-spec 中描述了这种语法，各种语言都对这种语法做了相关的实现

这个东西用途比较广泛，拿之前 Knative Eventing 的场景来说，如果我们需要过滤的事件信息比较复杂，一般的过滤手段比如前缀匹配、后缀匹配以及 Knative 提供的 ceSQL 就不够用了

这个时候 CEL 就能更好的处理这个场景，我们也以这个场景为例，看下 CEL 的能力

💻 简单了解

✨ 原理说明

cel-go 的实现是将配置构造成了一个语法树，随后根据配置来解析提供的数据，最终返回结果

需要注意的是，这里在构造语法树的时候，最终产出的是 protocol buffer 类型的数据

构建语法树

Three phases of parsing an expression (parse and check)
对提供的数据进行解析

Three phases of parsing an expression (evaluate)

✨ 快速操作

可以通过如下两个场景来尝试一下

字符替换构造
数据过滤

其中基本步骤如下

构造了一个 env，这里声明了支持解析的数据类型与相关数据
通过 env.compile 生成了我们提到的语法树
使用 env.Program 来生成处理使用的 prg
使用 prg 来处理数据

字符构造

通过 env.Compile(`"Hello world! I'm " + name + "."`) 构造的 Ast 处理数据 prg.Eval(map[string]any{ "name": "CEL"}) ，最终输出 Hello world! I'm CEL.

package examples

import (
    "fmt"
    "log"

    "github.com/google/cel-go/cel"
)

func ExampleSimple() {
    env, err := cel.NewEnv(cel.Variable("name", cel.StringType))
    if err != nil {
        log.Fatalf("environment creation error: %v\n", err)
    }
    ast, iss := env.Compile(`"Hello world! I'm " + name + "."`)
    // Check iss for compilation errors.
    if iss.Err() != nil {
        log.Fatalln(iss.Err())
    }
    prg, err := env.Program(ast)
    if err != nil {
        log.Fatalln(err)
    }
    out, _, err := prg.Eval(map[string]any{
        "name": "CEL",
    })
    if err != nil {
        log.Fatalln(err)
    }
    fmt.Println(out)
    // Output:Hello world! I'm CEL.
}

数据过滤

通过 env.Compile(`request.auth.claims.group == 'admin'`) 构造的 Ast 处理数据request(auth("user:me@acme.co", claims), time.Now()) ，最终判断结果为 true

func exercise2() {
    // Construct a standard environment that accepts 'request' as input and uses
    // the google.rpc.context.AttributeContext.Request type.
    env, err := cel.NewEnv(
        cel.Types(&rpcpb.AttributeContext_Request{}),
        cel.Variable("request",
            cel.ObjectType("google.rpc.context.AttributeContext.Request"),
        ),
    )
    if err != nil {
        glog.Exit(err)
    }
    ast, iss := env.Compile(`request.auth.claims.group == 'admin'`)
    if iss.Err() != nil {
        glog.Exit(iss.Err())
    }

    program, _ := env.Program(ast)

    // Evaluate a request object that sets the proper group claim.
    // Output: true
    claims := map[string]string{"group": "admin"}
    out, _, _ := program.Eval(request(auth("user:me@acme.co", claims), time.Now()))
    fmt.Println(out)

    // Output: true
}

💪 解决问题

以上简单示例中，能够对 CEL 部分能力有个大概了解，对于背景中提到的问题，这里没能解决

cel.NewEnv 中需要提供待处理数据的类型，否则它无法对数据进行处理，cel-go 中无法包含所有的类型，不过它提供了 Declarations 支持自定义一些数据类型，cloudevent 中基本都是 map 类型的数据，所以我们可以自定义一个 map 类型数据

比如我们就可以使用 decls.NewMapType(decls.String, decls.Dyn) 来自定义一个 map[string]any 的类型，这样我们就可以轻松处理上面提到的 cloudEvent 中的数据

package main

import (
    "fmt"
    "github.com/golang/glog"
    "github.com/google/cel-go/cel"
    "github.com/google/cel-go/checker/decls"
)

func main() {
    env, err := cel.NewEnv(
        cel.Declarations(
            decls.NewVar("cloudevent", decls.NewMapType(decls.String, decls.Dyn)),
        ),
    )
    if err != nil {
        glog.Exit(err)
    }
    ast, iss := env.Compile(`cloudevent.group.admin.name == 'yugougou'`)
    if iss.Err() != nil {
        glog.Exit(iss.Err())
    }

    program, _ := env.Program(ast)

    claims := map[string]any{"cloudevent": map[string]any{"group": map[string]any{"admin": map[string]any{"name": "yugougou"}}}}

    out, _, _ := program.Eval(claims)
    fmt.Println("filter cloudevent with admin name yugougou")
    fmt.Println(out)
    // Output: true

    claims = map[string]any{"cloudevent": map[string]any{"group": map[string]any{"admin": map[string]any{"name": "yuzp1996"}}}}

    out, _, _ = program.Eval(claims)
    fmt.Println("filter cloudevent with admin name yugougou")
    fmt.Println(out)
    // Output: false
}

输出结果

filter cloudevent with admin name yugougou
true
filter cloudevent with admin name yugougou
false

🦾 内置能力

CEL 定义了很多的语法，帮助我们更自由的过滤数据，不同语言都需要实现这些语法，参见标准定义列表

cel-go 就实现了这些语法，我们可以方便的使用

简单定义

复杂些的定义

在 复杂些的定义 中，存在一个 matches 的函数，matches 就是对正则表达式进行匹配处理，判断数据是否符合某个正则表达式

这里我们以 matches 为例，将上面的示例改造一下，就可以通过正则表达式来做匹配，结果也是一致的，符合预期的

package main

import (
    "fmt"
    "github.com/golang/glog"
    "github.com/google/cel-go/cel"
    "github.com/google/cel-go/checker/decls"
)

func main() {
    env, err := cel.NewEnv(
        cel.Declarations(
            decls.NewVar("cloudevent", decls.NewMapType(decls.String, decls.Dyn)),
        ),
    )
    if err != nil {
        glog.Exit(err)
    }
    // 由 == 表达式替换成正则表达式
    ast, iss := env.Compile(`cloudevent.group.admin.name.matches('^yugougou$')`)
    if iss.Err() != nil {
        glog.Exit(iss.Err())
    }

    program, _ := env.Program(ast)

    claims := map[string]any{"cloudevent": map[string]any{"group": map[string]any{"admin": map[string]any{"name": "yugougou"}}}}

    out, _, _ := program.Eval(claims)
    fmt.Println("filter cloudevent with admin name yugougou")
    fmt.Println(out)
    // Output: true

    claims = map[string]any{"cloudevent": map[string]any{"group": map[string]any{"admin": map[string]any{"name": "yuzp1996"}}}}

    out, _, _ = program.Eval(claims)
    fmt.Println("filter cloudevent with admin name yugougou")
    fmt.Println(out)
    // Output: false
}

输出结果

filter cloudevent with admin name yugougou
true
filter cloudevent with admin name yugougou
false

💪 自定义函数

在 内置能力定义 中我们可以看到，CEL 提供了很多内置的处理函数拓展了它的能力，这些能力能够解决我们大多数的问题

但是很多情况下由于业务逻辑复杂，或者为了提供更好的用户体验，我们会需要拓展下这些能力，CEL 提供了自定义函数来拓展我们需要的能力

比如我们从数组中获取某个元素，目前只能通过下标的表达式来获取，这就很不通用，因为这会到之后我们在编写 CEL 表达式的时候，需要提前知道我们要过滤的数据在什么位置

比如有如下数据，我们想获取 detail.first.content = abcd 元素的 issue.count 是否大于 0，那我们只能将 CEL 表达式写成 int(root.data[1].issues.count) > 0，这就会带来上面提到的，需要提前知道要过滤的数据在什么位置

root:
  data:
  - name: "ci-lint"
    issue:
      count: 0
  - name: "ci-lint-1"
    detail:
      first:
        content: abcd
    issue:
      count: 2

以该场景为例，我们可以定义一个自定义函数 kvelement(key，value)，这个函数支持通过指定 key 与 value 值来过滤数组中的元素，这样我们就可以通过 int(root.data.kvelement('detail.first.content','abcd').issues.count) > 0 来获取元素，以下是相关的实现

package main

import (
    "fmt"
    "github.com/google/cel-go/cel"
    "github.com/google/cel-go/checker/decls"
    "github.com/google/cel-go/common/types"
    "github.com/google/cel-go/common/types/ref"
    "github.com/google/cel-go/common/types/traits"
    "strings"
)

func main() {
    // 准备待过滤数据, 我们期望获取数组中 name=ci-lint 的元素
    data := map[string]interface{}{
        "root": map[string]interface{}{
            "data": []map[string]interface{}{
                {
                    "name":   "ci-lint",
                    "issues": map[string]interface{}{"count": 0},
                },
                {
                    "name": "ci-lint-1",
                    "detail": map[string]interface{}{
                        "first": map[string]interface{}{
                            "content": "abcd",
                        }},
                    "issues": map[string]interface{}{"count": 2},
                },
            },
        },
    }

    // 增加一个 map 的 list 的处理方式
    mapType := cel.MapType(cel.StringType, cel.DynType)
    arrayType := cel.ListType(mapType)

    // Env declaration.
    env, _ := cel.NewEnv(
        cel.Declarations(
            decls.NewVar("root", decls.NewMapType(decls.String, decls.Dyn)),
        ),
        // 将函数注入到 Env 中，起名为 kvelement，后续 cel 表达式中使用的话，也是使用这个名称
        cel.Function("kvelement",
            cel.MemberOverload(
                "get_contains_key_value_element",
                // 绑定参数，第一个参数是该函数的调用者，后续的参数是调用这个函数时的参数
                []*cel.Type{arrayType, cel.StringType, cel.DynType},
                mapType,
                // 绑定函数
                cel.FunctionBinding(ElementContainsKeyValue),
            ),
        ),
    )
    
    // 使用内置能力的方式
    ast, iss := env.Compile("int(root.data[1].issues.count) > 0")
    if iss != nil {
        panic(iss)
    }
    program, _ := env.Program(ast)
    out, _, err := program.Eval(data)
    if err != nil {
        panic(err)
    }
    // out is true
    fmt.Printf("out is %#v\n", out)
    
    // 使用自定义函数的方式
    ast, iss = env.Compile("int(root.data.kvelement('detail.first.content','abcd').issues.count) > 0")
    if iss != nil {
        panic(iss)
    }
    program, _ = env.Program(ast)
    out, _, err = program.Eval(data)
    if err != nil {
        panic(err)
    }
    // out is true
    fmt.Printf("out is %#v", out)
}

func ElementContainsKeyValue(args ...ref.Val) ref.Val {

    // 获取参数，调用者是数组，因此可以通过内置的 Lister 来处理
    // 第一个参数是 key,第二个是期望的 value
    lister := args[0].(traits.Lister)
    key := args[1]
    value := args[2]

    // 处理 lister 的参数，对数组的所有元素进行过滤
    iterator := lister.Iterator()
    for iterator.HasNext() == types.True {
        // 获取 key 值，key 的提供是通过 . 分割的，所以通过 . 获取每一层的 key 值
        keyString, err := getString(key.Value())
        if err != nil {
            return types.WrapErr(err)
        }
        keySplits := strings.Split(keyString, ".")

        // 获取数组中的各个值
        element := iterator.Next()
        elementValue, err := getStringInterfaceMap(element.Value())
        if err != nil {
            return types.WrapErr(err)
        }

        // 查看提供的 key 的第一层在当前数组元素中是否存在
        result := elementValue[keySplits[0]]
        if result == nil {
            continue
        }
        // 循环 key 的剩余层并且获取到对应的值
        for _, currentKey := range keySplits[1:] {
            middleResult, err := getStringInterfaceMap(result)
            if err != nil {
                continue
            }
            if middleResult[currentKey] != nil {
                result = middleResult[currentKey]
            } else {
                continue
            }
        }

        // 使用获取到的值和期望的值进行对比，确认是否找到相关的 element
        getResult, err := getString(result)
        if err != nil {
            return types.WrapErr(err)
        }
        expectResult, err := getString(value.Value())
        if err != nil {
            return types.WrapErr(err)
        }

        if getResult == expectResult {
            return element
        }
    }

    return types.WrapErr(fmt.Errorf("not matched"))
}

func getStringInterfaceMap(val interface{}) (map[string]interface{}, error) {
    msivalue, ok := val.(map[string]interface{})
    if !ok {
        return nil, fmt.Errorf("%#v not map[string]interface{}", msivalue)
    }
    return msivalue, nil
}
func getString(val interface{}) (string, error) {
    stringval, ok := val.(string)
    if !ok {
        return "", fmt.Errorf("%#v is not string", val)
    }
    return stringval, nil
}

如代码示例所示，我们可以将表达式从 int(root.data[1].issues.count) > 0 替换成 int(root.data.kvelement('detail.first.content','abcd').issues.count) > 0，使得 CEL 表达式更加通用

想要了解更多相关内容，官方自定义函数的教程也推荐参考，官方的示例循序渐进，描述的更加详细清楚

🧠 总结

目前只是简单的描述了 CEL 大概的能力， CEL 还有很多其他能力我还未探索到，比如更多的自定义函数以及更多的自定义类型等等，这些都极大的丰富了 CEL 的拓展性，有兴趣的可以自行探索

🤩 参考

语法参考书 cel-spec ( 定义了 common expression language 包含能力，不同语言实现的库会按照这里的定义进行实现 )
Golang CEL 实现库 cel-go (cel-spec Golang 版本的实现)
Golang CEL 代码实验室 cel-go codelabs

字符与字符串处理
CLR common language runtime windows下：ANSI函数只是一个对Unicode函数...
thinkphp 3.1.3 自定义函数和自定义CSS和js路径
自定义函数库如果在自定义函数 P 要在common 文件夹建立 common.php文件 p（$_SERVER）...
EL表达式与JSTL
EL 全名为 Expression Language 它原本是 JSTL 1.0 为方便存取数据所自定义的语言。当...
CLR IL JIT
CLR: Common Language Runtime IL: Intermediate Language JI...
CI 中自定义函数
在\system\core\Common.php中加入自定义函数---or---在application\help...
Streaminsets
Expression Language https://streamsets.com/documentation/...
Web 基础16 JSP之EL 入门
1.1 EL表达式的概述全称是Expression Language EL（Expression Lan...
生信流程工具-CWL
1. 简介 Common Workflow Language简称CWL 官网：https://www.common...
Fin-Expr: 一个新造的Java实现的表达式计算轮子
Fin-Expr: an expression evaluator 表达式计算工具，支持自定义函数和变量。 Fi...
Test Spring el with ExpressionPa
Spring expression language (SpEL) supports many functiona...

common expression language 自定义函数

📜 目录

👋 背景

💻 简单了解

✨ 原理说明

✨ 快速操作

字符构造

数据过滤

💪 解决问题

🦾 内置能力

💪 自定义函数

🧠 总结

🤩 参考

相关文章

字符与字符串处理

thinkphp 3.1.3 自定义函数和自定义CSS和js路径

EL表达式与JSTL

CLR IL JIT

CI 中自定义函数

Streaminsets

Web 基础16 JSP之EL 入门

生信流程工具-CWL

Fin-Expr: 一个新造的Java实现的表达式计算轮子

Test Spring el with ExpressionPa

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读