休息一下 發表於 2023-1-30 11:18:00

Go规则引擎：Gengine

<p>gengine是一款基于golang和AST(抽象语法树)开发的规则引擎,使用一套自定义的简单语法来定义规则来实现语言无关，并且还执行规则执行的各种模式，功能也很强大。</p>
<h1 id="核心api">核心API</h1>
<p>对于gengine的使用，我们先掌握几个核心的API。</p>
<ol>
<li><code>DataContext</code>：用于注入规则中需要使用的数据或者API。</li>
<li><code>RuleBuilder</code>：接收<code>DataContext</code>作为参数，并将用户传入的字符串构建出可执行的代码。</li>
<li><code>Gengine</code>：接收构建好的<code>RuleBuilder</code>，使用不同的模式执行规则。</li>
<li><code>GenginePool</code>：<code>Gengine</code>的实例池，提供线程安全的API，以供用户在高QPS下使用。也推荐直接使用<code>GenginePool</code>。</li>
</ol>
<p>gengine的使用大致分为下面的步骤：</p>
<ol>
<li>创建<code>DataContext</code>，并将规则使用的数据注入。</li>
<li>使用1中的<code>DataContext</code>作为参数实例化<code>RuleBuilder</code>并构建规则代码。</li>
<li>创建<code>Gengine</code>，按照模式执行2构建的规则代码。</li>
</ol>
<p>接下来就以一个示例快速了解gengine的使用。</p>
<h1 id="快速使用">快速使用</h1>
<p>现在有一个<code>User</code>结构体</p>
<pre><code class="language-go">type User struct {
        Name string
        Ageint64
        Male bool
}

func (u *User) GetNum(i int64) int64 {
        return i
}

func (u *User) Print(s string) {
        fmt.Println(s)
}

func (u *User) Say() {
        fmt.Println("hello world")
}
</code></pre>
<p>我们在规则中就需要使用这个结构体的实例来进行一些操作</p>
<pre><code class="language-go">const rule1 = `
rule "name test" "i can" salience 0
begin
        if 7 == User.GetNum(7) {
                User.Age = User.GetNum(89767) + 10000000
                User.Print("6666")
        } else {
                User.Name = "yyyy"
        }
end
`
</code></pre>
<p>按照上一部分的使用步骤，我们来编写代码。</p>
<ol>
<li>创建<code>DataContext</code>，并注入规则使用的数据或者API</li>
</ol>
<pre><code class="language-go">//规则要修改结构体数据，所以要传入指针
user := &amp;User{
                Name: "Calo",
                Age:0,
                Male: true,
        }
// 创建数据上下文，用来向规则中传入数据
dataContext := context.NewDataContext()
dataContext.Add("User", user)
</code></pre>
<ol start="2">
<li>创建<code>RuleBuilder</code>并构建规则代码</li>
</ol>
<pre><code class="language-go">ruleBuilder := builder.NewRuleBuilder(dataContext)
err := ruleBuilder.BuildRuleFromString(rule1)
if err != nil {
        log.Fatal(err)
}
</code></pre>
<ol start="3">
<li>创建<code>Gengine</code>并执行规则代码</li>
</ol>
<pre><code class="language-go">eng := engine.NewGengine()
err = eng.Execute(ruleBuilder, true) // true表示有多个规则的时候，其中一个执行失败也会继续执行其余的规则
if err != nil {
        log.Fatal(err)
}
log.Printf("%v\n", user)
</code></pre>
<p>使用起来并不复杂，甚至相当简单。对于Gengine的使用有了初步了解，接下来我们就进一步了解规则的语法。</p>
<h1 id="规则语法">规则语法</h1>
<p>gengine使用的自定义的简单语法，整体框架如下：</p>
<pre><code class="language-go">const rule = `
rule "rulename" "rule-description" salience10
begin

//规则体

end`
</code></pre>
<ul>
<li>rulename：规则名，必须唯一。多个同名的规则编译后会只剩下一个。</li>
<li>rule-description：规则描述，非必须。</li>
<li>salience：关键字，后跟数字表示优先级，数字越大优先级越高。</li>
<li>begin和end包裹的就是规则体，规则的具体逻辑在这里编写。</li>
</ul>
<p>规则体支持基本的数据类型，与go语言的基本类型一致。此外还支持了string类型。对于运算，规则体支持基本的算术四则运算，逻辑运算，比较运算，还有string的加法运算。</p>
<p>这些类型和运算的编写与go语言基本一致，不过规则体需要<strong>使用内置的isNil()函数来判断是否为nil</strong>。</p>
<pre><code class="language-go">const rule_else_if_test =`
rule "elseif_test" "test"
begin

a = 8
if a &lt; 1 {
        println("a &lt; 1")
} else if a &gt;= 1 &amp;&amp; a &lt;6 {
        println("a &gt;= 1 &amp;&amp; a &lt;6")
} else if a &gt;= 6 &amp;&amp; a &lt; 7 {
        println("a &gt;= 6 &amp;&amp; a &lt; 7")
} else if a &gt;= 7 &amp;&amp; a &lt; 10 {
        println("a &gt;=7 &amp;&amp; a &lt; 10")
} else      {
        println("a &gt; 10")
}
end`
</code></pre>
<p>规则体还支持conc并发语法块</p>
<pre><code class="language-go">const rule_conc_statement= `
rule "conc_test" "test"
begin
        conc{
                a = 3.0
                b = 4
                c = 6.8
                d = "hello world"
      e = "you will be happy here!"
        }
        println(a, b, c, d, e)
end`
</code></pre>
<p>conc块中的语句会并发执行，需要用户自己保证conc中调用的api是线程安全的。</p>
<h2 id="多级调用">多级调用</h2>
<p>gengine现在支持最多3级调用，A.B.C，并且能够进行<code>.</code>操作的只能是结构体或者指针。</p>
<h2 id="注释">注释</h2>
<p>规则体支持单行注释，与go语言一样以双斜杠（//）开头。</p>
<h2 id="内置变量">内置变量</h2>
<ul>
<li>@name: 指代当前规则名</li>
<li>@id：如果规则名是可以转为整数的字符串，那么@id就是这个整数，否则就是0.</li>
<li>@desc：当前规则的描述信息。</li>
<li>@sal：当前规则的优先级，类型为int64。</li>
</ul>
<h2 id="自定义变量">自定义变量</h2>
<ul>
<li>规则内支持的变量，只对当前规则可见，对其它规则不可见。（局部变量）</li>
<li>使用<code>DataContext</code>注入的变量，对所有规则可见。（全局变量）</li>
</ul>
<h2 id="return支持">return支持</h2>
<p>return可以用来直接返回规则执行，并且gengine的return可以返回不同类型的结果。</p>
<pre><code class="language-go">        rule := `
rule "return_in_statements"
begin
        if a &lt; 100 {
                return 5 + 6 * 6
        } else if a &gt;= 100 &amp;&amp; a &lt; 200{
                return "hello world"
        } else {
                return true
        }
end
        `
</code></pre>
<h1 id="规则更新与删除">规则更新与删除</h1>
<p>当规则数量少的时候，每次修改规则后重新编译所有的规则并没有什么问题。但是当规则数量成千上万之后，如果每次修改一个规则，就要重新编译全部的规则，那么就会造成资源的浪费。</p>
<p>于是Gengine支持两种更新方式，全量更新与增量更新。并且规则更新是线程安全的。</p>
<ul>
<li>全量更新：无论是新增还是修改一个规则，都会移除上一次所有规则，然后重新编译这一批传递过来的所有规则</li>
</ul>
<pre><code class="language-go">//单实例时
ruleBuilder := builder.NewRuleBuilder(dataContext)
e1 := ruleBuilder.BuildRuleFromString(rulesString) //这里全量更新

//pool中全量更新
//第一处
pool初始化的时候是全量更新的
//第二处
func (gp *GenginePool) UpdatePooledRules(ruleStr string) error
</code></pre>
<ul>
<li>增量更新：只对新增或者更新的规则进行编译，其余的规则则不进行任何操作</li>
</ul>
<pre><code class="language-go">//单实例 rule_builder.go
func (builder *RuleBuilder)BuildRuleWithIncremental(ruleString string) error

//pool中的增量更新接口
func (gp *GenginePool) UpdatePooledRulesIncremental(ruleStr string) error

</code></pre>
<p>当规则数量很大时，使用增量更新可以显著提高效率，降低资源消耗。</p>
<ul>
<li>批量删除</li>
</ul>
<pre><code class="language-go">//ruleBuilder中
func (builder *RuleBuilder) RemoveRules(ruleNames []string) error

//pool中
func (gp *GenginePool) RemoveRules(ruleNames []string) error

</code></pre>
<h1 id="执行模式">执行模式</h1>
<p>看一张官方的图，gengine支持的执行模式如何所示<br>
<img src="https://img2023.cnblogs.com/blog/1825095/202301/1825095-20230119145116487-2032968939.png" alt="image" loading="lazy"></p>
<p>这些执行模式都是基于gengine定义的规则的优先级。</p>
<ul>
<li>顺序执行模式：按照优先级从高到低的顺序依次执行。不过要注意：没有显式制定规定的优先级，那么规则的优先级不确定，相同优先级的执行顺序不一致。</li>
<li>并发执行模式：不考虑优先级，全部并发执行。</li>
<li>混合模式：选择一个优先级最高先执行，剩下的n-1个并发执行。</li>
<li>逆混合模式：选择优先级高的n-1个并发执行，最后执行剩下的一个优先级最低的规则。</li>
</ul>
<p>顺序模式下有如下的API：</p>
<ul>
<li><code>Execute</code>：顺序执行规则，参数b表示出错后是否继续执行。</li>
<li><code>ExecuteWithStopTagDirect</code>：与<code>Execute</code>功能类似，不过当执行某个规则之后,不想继续执行后面的规则,可以直接使用sTag结构体中的标识位来停止执行后面的规则。</li>
<li><code>ExecuteSelectedRules</code>：使用规则名来选择要执行的规则，选中的规则照样按照优先级执行。</li>
</ul>
<p>并发模式下API：</p>
<ul>
<li><code>ExecuteConcurrent</code>：并发执行规则，不考虑优先级</li>
<li><code>ExecuteSelectedRulesConcurrent</code>：同样适用规则名进行过滤，然后并发执行。</li>
</ul>
<p>混合模式API：</p>
<ul>
<li><code>ExecuteMixModel</code>：先选取优先级最高的一条规则执行,然后并发执行剩下的规则,如果第一个规则执行有error,则不会再执行后面的规则</li>
<li><code>ExecuteMixModelWithStopTagDirect</code>：当用户执行完了最高优先级的一条规则,如果不想执行剩下的规则,可以直接使用sTag结构体中的标识位来停止执行后面的规则</li>
<li><code>ExecuteSelectedRulesMixModel</code>：先经过规则名过滤。</li>
</ul>
<p>逆混合模式API：</p>
<ul>
<li><code>ExecuteInverseMixModel</code>：选取优先级最高的n-1个规则并发执行,这个n-1个规则执行完毕之后,剩下的最后一个优先级最低的规则开始执行; 如果前n-1个规则执行无异常，则继续执行最后一个规则</li>
<li><code>ExecuteSelectedRulesInverseMixModel</code>：使用规则名进行过滤。</li>
</ul>
<p>这里需要说明一下停止标志位，我们同样将其当作一个注入的数据来使用，在规则内我们可以将其设置为true或false，这样<code>Gengine</code>在执行的时候就可以根据规则执行完毕后停止标志位的值来确定是否继续执行规则。</p>
<pre><code class="language-go">//must default false
stag := &amp;engine.Stag{StopTag: false}
dataContext.Add("stag", stag)

eng := engine.NewGengine()
e2 := eng.ExecuteWithStopTagDirect(ruleBuilder, true, stag)
</code></pre>
<h2 id="nm执行模式">NM执行模式</h2>
<p>这是衍生出来的一种模式。按照优先级高低将规则分为两部分。第一阶段为前N个最高优先级的规则，剩下M个规则为第二阶段。<br>
按照两个阶段执行模式的不同，产生了如下子模式</p>
<table>
<thead>
<tr>
<th>执行模式</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>nSort - mConcurrent</td>
<td>前n个顺序执行，后m个并发执行</td>
</tr>
<tr>
<td>nConcurrent - mSort</td>
<td>前n个并发执行，后m个顺序执行</td>
</tr>
<tr>
<td>nConcurrent - mConcurrent</td>
<td>前n个并发执行，后m个也并发执行</td>
</tr>
<tr>
<td>nSort - mSort</td>
<td>就是普通的顺序执行</td>
</tr>
</tbody>
</table>
<p>实际上就只有3个子模式，也就是3个api</p>
<p><code>ExecuteNSortMConcurrent</code>：nSort-mConcurrent模式<br>
<code>ExecuteNConcurrentMSort</code>：nConcurrent-mSort模式<br>
<code>ExecuteNConcurrentMConcurrent</code>：nConcurrent-mConcurrent模式</p>
<p>与前面的api一样，这三个api也有对应的选择式，也就是使用规则名过滤出一部分规则，然后按照对应的执行模式执行。分别是：</p>
<p><code>ExecuteSelectedNSortMConcurrent</code><br>
<code>ExecuteSelectedNConcurrentMSort</code><br>
<code>ExecuteSelectedNConcurrentMConcurrent</code></p>
<h2 id="dag执行模式">DAG执行模式</h2>
<p>DAG是有向无环图执行模式，图的存储主要有邻接矩阵和临接连表两种方式，但是图的存储都是比较复杂的，gengine对此进行了优化。看官网上的图很容易就理解<br>
<img src="https://img2023.cnblogs.com/blog/1825095/202301/1825095-20230130101345462-78375127.png" alt="image" loading="lazy"></p>
<p>将DAG抽象为了图层，层内规则并发执行，层间规则顺序执行。用代码的语言来说就是</p>
<pre><code class="language-go">func (g *Gengine) ExecuteDAGModel(rb *builder.RuleBuilder, dag [][]string) error

func (gp *GenginePool) ExecuteDAGModel(dag [][]string, data mapinterface{}) (error, mapinterface{})
</code></pre>
<p>对于上面两个api的dag参数，<code>dag, dag</code>中的元素并发执行，但是<code>dag</code>执行完成后才顺序执行<code>dag</code>中的规则。</p>
<h1 id="引擎池">引擎池</h1>
<p>池化都是为了解决性能和并发安全问题的，例如数据库连接池。<br>
gengine在执行规则的过程中是有状态的，因此不能在一个请求的规则执行结束之前就执行下一个请求的规则，否则会破坏当前请求执行结果的正确性。</p>
<p>为了提高性能和并发问题，引入了引擎池，提供的所有api都是线程安全的。</p>
<pre><code class="language-go">//初始化一个规则引擎池
func NewGenginePool(poolMinLen ,poolMaxLen int64, em int, rulesStr string, apiOuter mapinterface{})
</code></pre>
<p>参数说明：</p>
<ul>
<li>poolMinLen：初始gengine实例个数</li>
<li>poolMaxLen：最多可实例化的gengine实例个数</li>
<li>em： 规则执行模式,em只能等于1、2、3、 4; em=1时,表示顺序执行规则,em=2的时候,表示并发执行规则,em=3的时候,表示混合模式执行规则,em=4的时候,表示逆混合模式执行规则;当使用<code>ExecuteSelectedRules</code>和<code>ExecuteSelectedRulesConcurrent</code>等指明了具体的执行模式的方法执行规则时,此参数自动失效</li>
<li>rulesStr：规则字符串</li>
<li>apiOuter：注入到gengine中的api。最好是公共api。与某次请求相关的参数，在执行时再进行注入。</li>
</ul>
<p>对于单实例的gengine的执行api，都有对应的引擎池版本的api。以其中一个为例</p>
<pre><code class="language-go">func (gp *GenginePool) Execute(data mapinterface{}, b bool) (error, mapinterface{})
</code></pre>
<p>其中<code>data</code>就是前面说明的与某次请求相关的注入数据。</p><br><br>
来源：https://www.cnblogs.com/smarticen/p/17061214.html
頁: [1]
查看完整版本: Go规则引擎：Gengine