开发者

详解如何使用Golang实现自定义规则引擎

开发者 https://www.devze.com 2024-08-15 11:16 出处：网络 作者： panco68120
目录支持的语句逻辑与算术运算流程控制高级语句规则语法的解析定义规则语法编写解析器语法解析器生成语法树遍历语法树生成语句表达式规则语法的执行支持自定义对象注入支持自定义方法注入支持并发执行使用场景业务风
相关专题：Golang实现自定义规则引擎Golang自定义规则引擎Golang规则引擎
目录
  • 支持的语句
  • 逻辑与算术运算
  • 流程控制
  • 高级语句
  • 规则语法的解析
  • 定义规则语法
    • 编写解析器语法
    • 解析器生成语法树
    • 遍历语法树生成语句表达式
    • 规则语法的执行
    • 支持自定义对象注入
    • 支持自定义方法注入
    • 支持并发执行
    • 使用场景
      • 业务风控
      • 运营活动
      • 内容分发

规则引擎的功能可以简化为当满足一些条件时触发一些操作，通常使用 DSL 自定义语法来表述。规则引擎需要先解析 DSL 语法形成语法树，然后遍历语法树得到完整的语法表达式，最后执行这些语法表达式完成规则的执行。

本文以gengine来探讨如何设计和实现一个自定义规则引擎。

支持的语句

为了满足基本的业务规则需求，规则引擎应该要支持的语句有：

逻辑与算术运算

  • 数学运算（+、-、*、/）
  • 逻辑运算（&&、||、!）
  • 比较运算（==、!=、>、<、>=、<=）

流程控制

  • 条件（IF ELSE）
  • 循环 (FOR)

高级语句

  • 对象属性访问（对象。属性）
  • 方法调用（func ()）

规则语法的解析

规则的 DSL 语法定义应该简单明了，gengine 使用了开源的语法解析器 Antlr4 来定义和解析规则语法。

定义规则语法

规则的 DSL 基本语法格式如下：

rule "rulename" "rule-describtion" salience  10
begin
//规则体
end

其中规则体为具体规则语句，由上述的 逻辑与算术运算、流程控制、高级语句 组合而成。

例如，判断为一个大额异常订单的规则体：

if Order.Price>= 1000000 {
    return
}

编写解析器语法

Antlr4 解析器语法定义文件后缀名为.g4，以下内容为解析器的语法定义，解析器根据语法定义去逐行解析生成语法树。

这里省略了一些非核心的语法定义并做了简化，完整内容查看 gengine.g4。

grammar gengine;

primary: ruleEntity+;
// 规则定义
ruleEntity:  RULE ruleName ruleDescription? salience? BEGIN ruleContent END;
ruleName : stringLiteral;
ruleDescription : stringLiteral;
salience : SALIENCE integer;
// 规则体
ruleContent : statements;
statements: statement* returnStmt?;

// 基本语句
statement : ifStmt | breakStmt;

expression : mathExpression
            | expression comparisonOperator expression
            | expression logicalOperator expression
            ;

mathExpression : mathExpression  mathMdOperator mathExpression
               | mathExpression  mathPmOperator mathExpression
               | expressionAtom
               | LR_BRACKET mathExpression RR_BRACKET
               ;

expressionAtom
    : functionCall
    | constant
    | variable
    ;
returnStmt : RETURN expression?;
ifStmt : IF expression LR_BRACE statements RR_BRACE elseIfStmt*  elseStmt?;
elseStmt : ELSE LR_BRACE statements RR_BRACE;

constant
    : booleanLiteral
    | integer
    | stringLiteral
    ;
functionArgs
    : (constant | variable  | functionCall | expression)  (','(constant | variable | functionCall | expression))*
    ;
integer : MINUS? INT;
stringLiteral: DQUOTA_STRING;
booleanLiteral : TRUE | FALSE;
functionCall : SIMPLENAME LR_BRACKET functionArgs? RR_BRACKET;
variable :  SIMPLENAME | DOTTEDNAME;
mathPmOperator : PLUS | MINUS;
mathMdOperator : MUL | DIV;
comparisonOperator : GT | LT | GTE | LTE | EQUALS | NOTEQUALS;

解析器生成语法树

如，判断为一个大额异常订单的规则：

rule "order-large-price" "订单大额金额" salience 10
begin
    if Order.Price >= 1000000 {
        return
    }
end

语法解析器解析之后，生成语法树：

详解如何使用Golang实现自定义规则引擎

遍历语法树生成语句表达式

解析器生成语法树之后，只需要遍历语法树即可得到完整的语句表达式。Antlr4 解析器会生成 Listener 接口，这些接口在遍历语法树时会被调用。

type gengineListener interface {
    antlr.ParseTreeListener
    // 省略了一些只列举了部分方法
    // EnterRuleEntity is called when entering the ruleEntity production.
    EnterRuleEntity(c *RuleEntityContext)
    // ExitRuleEntity is called when exiting the ruleEntity production.
    ExitRuleEntity(c *RuleEntityContext)
    // EnterRuleContent is called when entering the ruleContent production.
    EnterRuleContent(c *RuleContentContext)
    // ExitRuleContent is called when exiting the ruleContent production.
    ExitRuleContent(c *RuleContentContext)
    // EnterStatement is called when entering the statement production.
    EnterStatement(c *StatementContext)
    // ExitStatement is called when exiting the statement production.
    ExitStatement(c *StatementContext)
    // EnterIfStmt is called when entering the ifStmt production.
    EnterIfStmt(c *IfStmtContext)
    // ExitIfStmt is called when exiting the ifStmt production.
    ExitIfStmt(c *IfStmtContext)
    // EnterExpression is called when entering the expression production.
    EnterExpression(c *ExpressionContext)
    // ExitExpression is called when exiting the expression production.
    ExitExpression(c *ExpressionContext)
    // EnterInteger is called when entering the integer production.
    EnterInteger(c *IntegerContext)
    // ExitInteger is called when exiting the integer production.
    ExitInteger(c *IntegerContext)
}

可以发现在遍历语法树时，每个节点都有 EnterXXX() 和 ExitXXX() 方法存在，是成对出现的。

因此要遍历语法树只需要实现 gengineListener 接口即可，gengine 巧妙的引入栈结构，遍历完语法树后（树的递归遍历就是进栈出栈过程），就得到了完整的规则语句表达式。这里只列举部分方法，完整实现见 gengine_parser_listener。

type GengineParserListener struct {
    parser.BasegengineListener

    KnowledgeContext *base.KnowledgeContext
    Stack            *stack.Stack
}

func (g *GengineParserListener) EnterRuleEntity(ctx *parser.RuleEntityContext) {
    if len(g.ParseErrors) > 0 {
        return
    }
    entity := &base.RuleEntity{
        Salience: 0,
    }
    g.ruleName = ""
    g.ruleDescription = ""
    g.salience = 0
    g.Stack.Push(entity)
}

func (g *GengineParserListener) ExitRuleEntity(ctx *parser.RuleEntityContext) {
    if len(g.ParseErrors) > 0 {
        return
    }
    entity := g.Stack.Pop().(*base.RuleEntity)
    g.KnowledgeContext.RuleEntities[entity.RuleName] = entity
}

gengine 通过解析器解析规则内容之后，规则的数据结构如下：

详解如何使用Golang实现自定义规则引擎

全局的 hashmap 以规则名为 key，规则体为 value，规则体中的 ruleContent 为该规则所有的语句表达式列表，列表中的值指向具体的语句表达式实体，语句表达式实体由 逻辑与算术运算、流程控制（IF、FOR）等基本语句组成。

规则语法的执行

其实遍历语法树的过程中，将规则的执行逻辑也放入 ExitXXX() 方法，这样就能一并完成规则的解析和执行。但是 gengine 没有这么做，而是将规则的解析和执行解耦，因为规则的解析往往只需要初始化一次，或者在规则有变更时热更新解析，而规则的执行则是在需要校验规则的时候。

从 gengine 的规则数据结构可知，只需要遍历全局的 hashmap，即可按顺序执行所有的规则（顺序模式），执行每一个规则后会通过addResult()方法记录执行结果：

// 顺序模式
func编程客栈 (g *Gengine) Execute(rb *builder.RuleBuilder, b bool) error {
    for _, r := range rb.Kc.RuleEntities {
        v, err, bx := r.Execute(rb.Dc)
        if bx {
            // 记录每个规则执行结果
            g.addResult(r.RuleName, v)
        }
    }
    // 省略部分
    ...
}

对于某一个规则的执行，则会去遍历规则体 ruleContent 的所有语句表达式列表，然后按顺序去执行该规则下的所有语句表达式：

func (s *Statements) EvaLuate(dc *context.DataContext, Vars map[string]reflect.Value) (reflect.Value, error, bool) {
    for _, statement := range s.StatementList {
        v, err, b := statement.Evaluate(dc, Vars)
        if err != nil {
            return reflect.ValueOf(nil), err, false
        }

        if b {
            // return的情况不需要继续执行
            return v, nil, b
        }
    if s.ReturnStatement != nil {
        return s.ReturnStatement.Evaluate(dc, Vars)
    }
    return reflect.ValueOf(nil), nil, false
}

gengine 为每个语句类型都实现了 Evaluate() 方法，这里只讨论 IF 语句的执行：

type IfStmt struct {
    Expression     *Expression
    StatementList  *Statements
    ElseIfStmtList []*ElseIfStmt
    ElseStmt       *ElseStmt
}

func (i *IfStmt) Evaluate(dc *context.DataContext, Vars map[string]reflect.Value) (reflect.Value, error, bool) {
    // 执行条件表达式
    it, err := i.Expression.Evaluate(dc, Vars)
    if err != nil {
        return reflect.ValueOf(nil), err, false
    }
    // 执行条件为真时的语句
    if it.Bool() {
        if i.StatementList == nil {
            return reflect.ValueOf(nil), nil, false
        } else {
            return i.StatementList.Evaluate(dc, Vars)
        }
    }

    return reflect.ValueOf(nil), nil, false
}

其中条件表达式Expression.Evaluate()为计算条件表达式的值：

func (e *Expression) Evaluate(dc *context.DataContext, Vars map[string]reflect.Value) (reflect.Value, error) {
    // 原子表达式
    var atom reflect.Value
    if e.ExpressionAtom != nil {
        evl, err := e.ExpressionAtom.Evaluate(dc, Vars)
        if err != nil {
            return reflect.ValueOf(nil), err
        }
        atom = evl
    }
    
    // 比较操作
    if e.ComparisonOperator != "" {
        // 计算左值
      编程客栈  lv, err := e.ExpressionLeft.Evaluate(dc, Vars)
        if err != nil {
            return reflect.ValueOf(nil), err
        }
        // 计算右值
        rv, err := e.ExpressionRight.Evaluate(dc, Vars)
        if err != nil {
         python   return reflect.ValueOf(nil), err
        }
        // 省略了类型转化
        switch e.ComparisonOperator {
        case "==":
            b = reflect.ValueOf(lv == rv)
            break
        case "!=":
            b = reflect.ValueOf(lv != rv)
            break
        case ">":
            b = reflect.ValueOf(lv > rv)
            break
        case "<":
            b = reflect.ValueOf(lv < rv)
            break
        case ">=":
            b = reflect.ValueOf(lv >= rv)
            break
        case "<=":
            b = reflect.ValueOf(lv <= rv)
            break
        }
    }
}

递归执行到ExpressionAtom.Evaluate()原子表达式时，就可以得到该原子表达式的值以结束递归：

func (e *ExpressionAtom) Evaluate(dc *context.DataContext, Vars map[string]reflect.Value) (reflect.Value, error) {
    if len(e.Variable) > 0 {
        // 是变量则取变量值，通过反射获取注入的自定义对象值
        return dc.GetValue(Vars, e.Variable)
    } else if e.Constant != nil {
        // 是常量就返回值
        return e.Constant.Evaluate(dc, Vars)
    }
    // 省略部分
}

支持自定义对象注入

在上下文中注入自定义对象后，就可以在规则中使用注入的对象。使用例子：

// 规则体
rule "test-object" "测试自定义对象" salience 10
begin
    // 访问自定义对象Order
    if Order.Price >= 1000000 {
        return
    }
end

// 注入自定义对象Order
dataContext := gctx.NewDataContext()
dataContext.Add("Order", Order)

现在来看下 gengine 的具体实现，主要是使用反射特性：

func (dc *DataContext) Add(key string, obj interface{}) {
    dc.lockBase.Lock()
    defer dc.lockBase.Unlock()
    dc.base[key] = refpythonlect.ValueOf(obj)
}

gengine 解析规则时会将自定义对象标记为variable类型，通过 GetValue(php) 获取自定义对象属性值：

// 获取变量值
func (dc *DataContext) GetValue(Vars map[string]reflect.Value, variable string) (reflect.Value, error) {
    if strings.Contains(variable, ".") {
        // 对象a.b
        structAndField := strings.Split(variable, ".")
        if len(structAndField) == 2 {
            a := structAndField[0]
            b := structAndField[1]
            // 获取注入的对象
            dc.lockBase.Lock()
            v, ok := dc.base[a]
            dc.lockBase.Unlock()
            if ok {
                return core.GetStructAttributeValue(v, b)
            }
        }
    }
}

// 反射获取对象属性值
func GetStructAttributeValue(obj reflect.Value, fieldName string) (reflect.Value, error) {
    stru := obj
    var attrVal reflect.Value
    if stru.Kind() == reflect.Ptr {
        attrVal = stru.Elem().FieldByName(fieldName)
    } else {
        attrVal = stru.FieldByName(fieldName)
    }
    return attrVal, nil
}

支持自定义方法注入

同样在上下文中注入自定义方法后，也可以在规则中使用注入的方法。使用例子：

// 规则体
rule "test-func" "测试自定义方法" salience 10
begin
    // 自定义方法GetCount获取指标数据（患者当天的订单数量）
    num = GetCount("order-patient-id", Order.PatientId)
    if num >= 5 {
        return
    }
end

// 注入自定义方法GetCount
dataSvc := s.indicatorDao.NewDataService(ctx)
dataContext := gctx.NewDataContext()
dataContext.Add("GetCount", dataSvc.GetCount)

gengine 自定义方法的注入也是使用反射来实现，自定义方法的注入同自定义对象一样也是使用 Add() 方法注入。

gengine 解析规则时会将自定义方法标记为functionCall类型：

func (dc *DataContext) ExecFunc(Vars map[string]reflect.Value, funcName string, parameters []reflect.Value) (reflect.Value, error) {
    // 获取注入的方法
    dc.lockBase.Lock()
    v, ok := dc.base[funcName]
    dc.lockBase.Unlock()
    if ok {
        args := core.ParamsTypeChange(v, parameters)
        // 调用方法
        res := v.Call(args)
        raw, e := core.GetRawTypeValue(res)
        if e != nil {
            return reflect.ValueOf(nil), e
        }
        return raw, nil
    }
}

支持并发执行

通常情况下顺序模式执行即可满足要求，但是当规则数量比较大时，顺序执行的耗时就会比较长。

详解如何使用Golang实现自定义规则引擎

规则引擎在执行所有规则的时候，其实是遍历全局的 hashmap 然后再顺序执行每一个规则，由于每个规则之间没有依赖关系，因此可以用每一个规则一个协程来并发执行。

func (g *Gengine) ExecuteConcurrent(rb *builder.RuleBuilder) error {
    var wg sync.WaitGroup
    wg.Add(len(rb.Kc.RuleEntities))
    for _, r := range rb.Kc.RuleEntities {
        rr := r
        // 协程并发
        go func() {
            v, e, bx := rr.Execute(rb.Dc)
            if bx {
                g.addResult(rr.RuleName, v)
            }
            wg.Done()
        }()
    }
    wg.Wait()
    // 省略部分
}

使用场景

有了规则引擎之后，很多在业务代码中的 if-else、switch 硬编码，都能抽象为规则并使用规则引擎，这样能通过配置规则代替硬编码，能极大地缩短变更上线时间。

业务风控

通过业务数据分析，可以抽象出用户异常行为的规则：

详解如何使用Golang实现自定义规则引擎

然后，风控系统在判断是否为风险操作时，只需要规则引擎加载并执行风控规则，即可得到结果。想要提高风控系统的准确性，只需要不断地迭代完善风控规则。

详解如何使用Golang实现自定义规则引擎

规则引擎在业务风控的实践，可以参考 基于准实时规则引擎的业务风控实践。

运营活动

拿最常见的抽奖和做任务 2 种运营活动来说，都可以将具体活动逻辑抽象为业务规则：① 抽奖，不同的人&不同的场景对应不同的奖池（中奖概率与奖品集合规则）；② 做任务，任务领取规则、任务完成指标动态可配（任务规则）；

详解如何使用Golang实现自定义规则引擎

内容分发

针对某些特定的用户或者某种场景的用户，下发特定的展示内容或者推送短信等触达消息，都可以将这些特定用户的逻辑梳理为内容分发规则。

详解如何使用Golang实现自定义规则引擎

以上就是详解如何使用golang实现自定义规则引擎的详细内容，更多关于Golang自定义规则引擎的资料请关注编程客栈(www.devze.com)其它相关文章！

0

上一篇:

:下一篇

更多 开发 相关资讯：

精彩评论

暂无评论...
登录 注册
Qedev.com
验证码 换一张
取 消

关注公众号

热门标签

图文推荐

mysql字符集引起的java.sql.SQLException:Incorrect string value:问题

mysql字符集引起的java.sql.SQLException:Incorrect string value:问题
解决Feign异步调用丢失上下文问题

解决Feign异步调用丢失上下文问题
一文教会你使用Python来下一场雪

一文教会你使用Python来下一场雪
利用python调整Excel行高和列宽的操作示例

利用python调整Excel行高和列宽的操作示例
Python字符串检索方式

Python字符串检索方式
Android中常见内存泄漏的场景和解决方案详解

Android中常见内存泄漏的场景和解决方案详解
python解析网页上的json数据并保存到EXCEL

python解析网页上的json数据并保存到EXCEL
使用wxPython创建一个文件夹结构生成器

使用wxPython创建一个文件夹结构生成器

开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9