正文

活动规则是根据用户购买订单的金额给用户送相应的积分，购买的越多送的积分越多，用户可以使用积分来兑换相应的商品，我们这次活动的力度很大，肯定会吸引很多的用户参加，产品经理小王兴高采烈唾液横飞的对小明讲到。小明心想，又tm来这套，这次需求又要变更多少次呢？表面上还的配合，说赶紧把规则给我们吧，早点开发早点上线，小王说这次需求老简单啦，估计你们两个小时就搞定了，不信你看需求文档。

100元以下, 不加分 
100元-500元 加100分 
500元-1000元 加500分 
1000元 以上 加1000分

小明一看，这需求果然简单呀，作为一个工作了两三年的程序员来讲，这不就是小case，半天搞定，送积分的核心代码如下：

public void execute() throws Exception   
      
    List<Order> orderList = getInitData();
    for (int i=0; i<orderList.size(); i++)  
        Order order = orderList.get(i);  
        if (order.getAmout() <= 100)  
            order.setScore(0);  
            addScore(order);  
        else if(order.getAmout() > 100 && order.getAmout() <= 500)  
            order.setScore(100);  
            addScore(order);  
        else if(order.getAmout() > 500 && order.getAmout() <= 1000)  
            order.setScore(500);  
            addScore(order);  
        else  
            order.setScore(1000);  
            addScore(order);

上线运行了半天之后，财务部的小财突然监测到活动账户的金额大为减少，发现产品做活动竟然没有通知到他，非常不爽，于是给领导小马说，这样大规模的活动，对公司财务有压力，领导小马权衡了一番说，这样吧活动继续，但是金额翻倍再送积分，于是规则变成了这样：200元以下不给积分，1000元以下给100积分…

小明看领导都发话了，没办法改呀，不过也简单，就是将里面的值都翻了倍，在投产上去，只是挨了不少测试的白眼。

活动又进行了一天，运营人员通过后台监控发现提到2倍以后，用户积极性变的很差，活动效果不理想，和领导商议了一下，改为最初规则的1.5倍，及150元一下不给积分，750元以下给100积分… 小明这时候的心情大概是这样子的，一万个下图动物狂奔而过。

没办法还得改不是，当然这次小明可学乖了，将这些数据（多少元送多少分）存到了数据库中，当老板再改主意的时候，只要改一下数据库的值就可以了，小明为自己的明聪明到有点小高兴。

核心代码：

public void execute() throws Exception   
      
    List<Order> orderList = getInitData();
    List<int> values = getTableValues();
    for (int i=0; i<orderList.size(); i++)  
        Order order = orderList.get(i);  
        if (order.getAmout() <= values.get(0))  
            order.setScore(values.get(3));  
            addScore(order);  
        else if(order.getAmout() > values.get(0) && order.getAmout() <= values.get(1))  
            order.setScore(values.get(4));  
            addScore(order);  
        else if(order.getAmout() > values.get(1) && order.getAmout() <= values.get(2))  
            order.setScore(values.get(5));  
            addScore(order);  
        else  
            order.setScore(values.get(6));  
            addScore(order);

正当小明得意洋洋的打了个最新版本投产上线之后，产品经理小王说积分规则层次太少了，由以前的4组变成8组，小明此刻的心情：kao …

小明想这样下去非得被他们弄死，必须要找找有什么技术可以将活动规则和代码解耦，不管规则如何变化，执行端不用动。小明搜了半天还真有这样的东西，那就是规则引擎，那么规则引擎到底是什么东西呢？我们来看看。

规则引擎

规则引擎：全称为业务规则管理系统，英文名为BRMS。规则引擎的主要思想是将应用程序中的业务决策部分分离出来，并使用预定义的语义模块编写业务决策（业务规则），由用户或开发者在需要时进行配置、管理。需要注意的是规则引擎并不是一个具体的技术框架，而是指的一类系统，即业务规则管理系统。

java开源的规则引擎有：Drools、Easy Rules、Mandarax、IBM ILOG。使用最为广泛并且开源的是Drools。

主要应用场景：

对于一些存在比较复杂的业务规则并且业务规则会频繁变换的系统比较适合使用规则引擎，如下:

风控系统-------风险贷款、风险评估
反欺诈项目-----银行贷款、征信验证
决策平台-------财务计算
电商平台------满减、打折、加价购

Drools 简介

Drools 是用 Java 语言编写的开放源码规则引擎，使用 Rete 算法对所编写的规则求值。Drools 允许使用声明方式表达业务逻辑。可以使用非 XML 的本地语言编写规则，从而便于学习和理解。并且，还可以将 Java 代码直接嵌入到规则文件中，这令 Drools 的学习更加吸引人。

Drools 还具有其他优点：

非常活跃的社区支持
易用
快速的执行速度
在 Java 开发人员中流行
与 Java Rule Engine API（JSR 94）兼容

Drools 是业务逻辑集成平台，被分为4个项目：

Drools Guvnor (BRMS/BPMS)：业务规则管理系统
Drools Expert (rule engine)：规则引擎，drools的核心部分
Drools Flow (process/workflow)：工作流引擎
Drools Fusion (cep/temporal reasoning)：事件处理

官网：http://www.drools.org/#
官方文档：http://www.drools.org/learn/documentation.html

在项目中使用drools 时，即可以单独使用也可以整合spring使用，如果是单独使用仅需要导入以下maven 依赖即可。

  <!--添加规则引擎依赖-->
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>7.73.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-mvel</artifactId>
            <version>7.73.0.Final</version>
        </dependency>

Drools API 开发步骤如下：

二、Drools 快速入门

电商平台促销积分规则

100元以下, 不加分 
100元-500元 加100分 
500元-1000元 加500分 
1000元 以上 加1000分

开发实现

第一步：创建Maven项目，添加Drools 规则引擎依赖。

 <!--添加规则引擎依赖-->
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>7.73.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-mvel</artifactId>
            <version>7.73.0.Final</version>
        </dependency>
        <!--添加单元测试工具类-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

第二步：根据drools要求创建resources/META-INF/kmodule.xml 配置文件

需要有一个配置文件告诉代码规则文件drl 在哪里，在drools中这个文件就是kmodule.xml。

<?xml version="1.0" encoding="UTF-8"?>
<kmodule xmlns="http://www.drools.org/xsd/kmodule">
    <!--
    name:指定kbase 名称，可以是任意但必须唯一
    packages:指定规则文件存放目录，依据实际情况进行填写
    default:指定当前的kbase 是否为默认
    -->
    <kbase name="rules" packages="rules" default="true">
        <!--
        name:指定ksession名称，可以是任意但必须唯一
        default:指定ksession 是否为默认
        -->
        <ksession name="ksession-rules" default="true"/>
    </kbase>
</kmodule>

第三步：创建业务实体对象

package com.zzg.model;

public class Order implements java.io.Serializable 

    private int amount; //订单金额

    private int score; //订单积分

    @Override
    public String toString() 
        return "Order" +
                "amount=" + amount +
                ", score=" + score +
                '';
    

    public int getAmount() 
        return amount;
    

    public void setAmount(int amount) 
        this.amount = amount;
    

    public int getScore() 
        return score;
    

    public void setScore(int score) 
        this.score = score;

第四步：创建规则文件，在resources/rules/score-rules.drl

package rules;

import com.zzg.model.Order;

// 100 元以下不加分
rule "score_1"
when
    $order:Order(amount<100);
then
    $order.setScore(0);
    System.out.println("触发100元以下,不加积分");
end
// 100-500 元, 加100积分
rule "score_2"
when
    $order:Order(amount>100 && amount <= 500);
then
    $order.setScore(100);
    System.out.println("触发100-500 元, 加100积分");
end
// 500-10000 元, 加500积分
rule "score_3"
when
    $order:Order(amount>500 && amount <= 1000);
then
    $order.setScore(500);
    System.out.println("触发500-1000 元, 加500积分");
end
// 大于1000 元, 加1000积分
rule "score_4"
when
    $order:Order(amount>1000);
then
    $order.setScore(1000);
    System.out.println("触发大于1000 元, 加1000积分");
end

第五步：单元测试

package com.zzg;

import com.zzg.model.Order;
import org.junit.Test;
import org.kie.api.KieServices;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;

public class TestDrools 
    @Test
    public void test1() 
        // 第一步
        KieServices kieServices = KieServices.Factory.get();
        // 第二步
        KieContainer kieContainer = kieServices.getKieClasspathContainer();
        // 第三步
        KieSession kieSession = kieContainer.newKieSession();
        // 业务对象
        Order order = new Order();
        order.setAmount(100);
        // 第四步
        kieSession.insert(order);
        // 第五步：执行规则引擎
        kieSession.fireAllRules();
        // 第六步：关闭session
        kieSession.dispose();

        System.out.println("指定规则引擎后的结果：" + order.getScore());

效果截图:

23:01:01.112 [main] INFO org.drools.compiler.kie.builder.impl.KieContainerImpl - End creation of KieBase: rules
23:01:01.144 [main] DEBUG org.drools.core.common.DefaultAgenda - State was INACTIVE is now FIRING_ALL_RULES
23:01:01.144 [main] DEBUG org.drools.core.common.DefaultAgenda - State was FIRING_ALL_RULES is now HALTING
23:01:01.144 [main] DEBUG org.drools.core.common.DefaultAgenda - State was HALTING is now INACTIVE
23:01:01.144 [main] DEBUG org.drools.core.common.DefaultAgenda - State was INACTIVE is now DISPOSED
指定规则引擎后的结果：0

三、Drools 规则引擎构成及其核心类

Drools规则引擎构成

drools规则引擎由以下几部分构成：

Working Memory（工作内存）
Rules（规则库）
Inference Engine(推理引擎）

其中Inference Engine(t推理引擎）又包含如下：

Pattern Match(匹配器）具体匹配那一个规则，由它来完成
Agenda(议程）
Execution Engine(执行引擎）

Drools规则引擎概念

Working Memory：工作内存，drools规则引擎会从Working Memory中获取数据并和规则文件中定义的规则进行模式匹配，所以我们开发的应用程序只需要将我们的数据插入到Working Memory中即可，例如本案例中我们调用kieSession.insert(order)就是将order对象插入到了工作内存中。

Fact：事实，是指在drools 规则应用当中，将一个普通的JavaBean插入到Working Memory后的对象就是Fact对象，例如本案例中的Order对象就属于Fact对象。Fact对象是我们的应用和规则引擎进行数据交互的桥梁或通道。

Rules：规则库，我们在规则文件中定义的规则都会被加载到规则库中。

Pattern Matcher：匹配器，将Rule Base中的所有规则与Working Memory中的Fact对象进行模式匹配，匹配成功的规则将被激活并放入Agenda中。

Agenda：议程，用于存放通过匹配器进行模式匹配后被激活的规则。

四、Drools 基础语法

规则文件构成

drl是Drools Rule Language的缩写。

一套完整的规则文件内容构成如下：

关键字	描述
package	包名，只限于逻辑上的管理，同一个包名下的查询或者函数可以直接调用
import	用于导入类或者静态方法
global	全局变量
function	自定义函数
query	查询
rule end	规则体

规则体语法结构

一个规则通常包含三个部分：属性部分（attribute）、条件部分（LHS）和结果部分(RHS)

语法结构体：

rule "ruleName"
    attributes
    when
        LHS 
    then
        RHS
end

rule：关键字，表示规则开始，参数为规则的唯一名称。

attributes：规则属性，是rule与when之间的参数，为可选项。

when：关键字，后面跟规则的条件部分。

LHS(Left Hand Side)：是规则的条件部分的通用名称。它由零个或多个条件元素组成。如果LHS为空，则它将被视为始终为true的条件元素。（左手边）

then：关键字，后面跟规则的结果部分。

RHS(Right Hand Side)：是规则的后果或行动部分的通用名称。（右手边）

end：关键字，表示一个规则结束。

规则注释

在drl形式的规则文件中使用注释和Java类中使用注释一致，分为单行注释和多行注释。

单行注释用"//"进行标记，多行注释以"/"开始，以"/"结束。如下示例：

//规则rule1的注释，这是一个单行注释
rule "rule1"
    when
    then
        System.out.println("rule1触发");
end

/*
规则rule2的注释，
这是一个多行注释
*/
rule "rule2"
    when
    then
        System.out.println("rule2触发");
end

Pattern模式匹配

Drools中的匹配器可以将Rule Base中的所有规则与Working Memory中的Fact对象进行模式匹配，那么我们就需要在规则体的LHS部分定义规则并进行模式匹配。LHS部分由一个或者多个条件组成，条件又称为pattern。

语法：

pattern的语法结构为：绑定变量名:Object(Field约束)

其中绑定变量名可以省略，通常绑定变量名的命名一般建议以$开始。如果定义了绑定变量名，就可以在规则体的RHS部分使用此绑定变量名来操作相应的Fact对象。Field约束部分是需要返回true或者false的0个或多个表达式。

入门案例中：

package rules;

import com.zzg.model.Order;

// 100 元以下不加分
rule "score_1"
when
    $order:Order(amount<100);
then
    $order.setScore(0);
    System.out.println("触发100元以下,不加积分");
end

通过上面的例子我们可以知道，匹配的条件为：

1、工作内存中必须存在Order这种类型的Fact对象-----类型约束

2、Fact对象的price属性值必须小于100------属性约束

以上条件必须同时满足当前规则才有可能被激活。

绑定变量既可以用在对象上，也可以用在对象的属性上。入门案例如下：

// 100-500 元, 加100积分
rule "score_2"
when
    $order:Order($fieldAmount:amount > 100  && amount <= 500);
then
    System.out.println("$fieldAmount=" + $fieldAmount);
    $order.setScore(100);
    System.out.println("触发100-500 元, 加100积分");
end

LHS部分还可以定义多个pattern，多个pattern之间可以使用and或者or进行连接，也可以不写，默认连接为and。

规则比较操作符

Drools提供的比较操作符，如下表：

符号	说明
>	大于
<	小于
>=	大于等于
<=	小于等于
==	等于
!=	不等于
contains	检查一个Fact对象的某个属性值是否包含一个指定的对象值
not contains	检查一个Fact对象的某个属性值是否不包含一个指定的对象值
memberOf	判断一个Fact对象的某个属性是否在一个或多个集合中
not memberOf	判断一个Fact对象的某个属性是否不在一个或多个集合中
matches	判断一个Fact对象的属性是否与提供的标准的Java正则表达式进行匹配
not matches	判断一个Fact对象的属性是否不与提供的标准的Java正则表达式进行匹配

操作步骤

第一步：创建实体类，用于测试比较操作符

package com.zzg.model;

import java.util.List;

public class ComparisonEntity implements java.io.Serializable 
    /**
     * 名字集合
     */
    private String names;

    /**
     * 字符串集合
     */
    private List<String> list;

    @Override
    public String toString() 
        return "ComparisonEntity" +
                "names='" + names + '\\'' +
                ", list=" + list +
                '';
    

    public String getNames() 
        return names;
    

    public void setNames(String names) 
        this.names = names;
    

    public List<String> getList() 
        return list;
    

    public void setList(List<String> list) 
        this.list = list;

第二步：在/resources/rules下创建规则文件comparison.drl

package rules

import com.zzg.model.ComparisonEntity;

/*
 用于测试Drools提供的比较操作符
*/

//测试比较操作符contains
rule "rule_comparison_contains"
    when
        ComparisonEntity(names contains "张三")
        ComparisonEntity(list contains names)
    then
        System.out.println("规则rule_comparison_contains触发");
end

//测试比较操作符not contains
rule "rule_comparison_notContains"
    when
        ComparisonEntity(names not contains "张三")
        ComparisonEntity(list not contains names)
    then
        System.out.println("规则rule_comparison_notContains触发");
end

//测试比较操作符memberOf
rule "rule_comparison_memberOf"
    when
        ComparisonEntity(names memberOf list)
    then
        System.out.println("规则rule_comparison_memberOf触发");
end

//测试比较操作符not memberOf
rule "rule_comparison_notMemberOf"
    when
        ComparisonEntity(names not memberOf list)
    then
        System.out.println("规则rule_comparison_notMemberOf触发");
end

//测试比较操作符matches
rule "rule_comparison_matches"
    when
        ComparisonEntity(names matches "张.*")
    then
        System.out.println("规则rule_comparison_matches触发");
end

//测试比较操作符not matches
rule "rule_comparison_notMatches"
    when
        ComparisonEntity(names not matches "张.*")
    then
        System.out.println("规则rule_comparison_notMatches触发");
end

第三步：编写单元测试

 @Test
    public void test2() 
        // 第一步
        KieServices kieServices = KieServices.Factory.get();
        // 第二步
        KieContainer kieContainer = kieServices.getKieClasspathContainer();
        // 第三步
        KieSession kieSession = kieContainer.newKieSession();
        // 业务对象
        ComparisonEntity comparisonEntity = new ComparisonEntity();
        comparisonEntity.setNames("张三");
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        comparisonEntity.setList(list);
        // 第四步
        kieSession.insert(comparisonEntity);
        // 第五步：执行规则引擎
        kieSession.fireAllRules();
        // 第六步：关闭session
        kieSession.dispose();

效果截图：

09:52:42.457 [main] DEBUG org.drools.core.common.DefaultAgenda - State was INACTIVE is now FIRING_ALL_RULES
规则rule_comparison_contains触发
规则rule_comparison_memberOf触发
规则rule_comparison_matches触发
09:52:42.488 [main] DEBUG org.drools.core.common.DefaultAgenda - State was FIRING_ALL_RULES is now HALTING
09:52:42.488 [main] DEBUG org.drools.core.common.DefaultAgenda - State was HALTING is now INACTIVE
09:52:42.488 [main] DEBUG org.drools.core.common.DefaultAgenda - State was INACTIVE is now DISPOSED

执行指定规则

在调用规则代码时，满足条件的规则都会被执行。那么如果我们只想执行其中的某个规则如何实现呢？

Drools给我们提供的方式是通过规则过滤器来实现执行指定规则。对于规则文件不用做任何修改，只需要修改Java代码即可，如下：

//通过规则过滤器实现只执行指定规则
kieSession.fireAllRules(new kieSession.fireAllRules(new RuleNameEqualsAgendaFilter("rule 名称"));

关键字

Drools的关键字分为：硬关键字(Hard keywords)和软关键字(Soft keywords)。

硬关键字是我们在规则文件中定义包名或者规则名时明确不能使用的，否则程序会报错。软关键字虽然可以使用，但是不建议使用。

硬关键字包括：true false null

软关键字包括：lock-on-active date-effective date-expires no-loop auto-focus activation-group agenda-group ruleflow-group entry-point duration package import dialect salience enabled attributes rule extend when then template query declare function global eval not in or and exists forall accumulate collect from action reverse result end over init

示例：

rule true //不可以

rule "true" 可以

五、Drools 规则属性 attributes

前面我们已经知道了规则体的构成如下：

rule "ruleName"
    attributes
    when
        LHS
    then
        RHS
end

本章节就是针对规则体的attributes属性部分进行讲解。Drools中提供的属性如下表(部分属性)：

属性名	说明
salience	指定规则执行优先级
dialect	指定规则使用的语言类型，取值为java和mvel
enabled	指定规则是否启用
date-effective	指定规则生效时间
date-expires	指定规则失效时间
activation-group	激活分组，具有相同分组名称的规则只能有一个规则触发
agenda-group	议程分组，只有获取焦点的组中的规则才有可能触发
timer	定时器，指定规则触发的时间
auto-focus	自动获取焦点，一般结合agenda-group一起使用
no-loop	防止死循环，防止自己更新规则再次触发
lock-on-active	no-loop增强版本。可防止别人更新规则再次出发

enabled属性

enabled属性对应的取值为true和false，默认值为true。

用于指定当前规则是否启用，如果设置的值为false则当前规则无论是否匹配成功都不会触发

第一步：创建实体类，用于测试属性attributes

package com.zzg.model;

public class AttributesEnabledEntity implements java.io.Serializable 

    private int num;

    @Override
    public String toString() 
        return "AttributesEnabledEntity" +
                "num=" + num +
                '';
    

    public int getNum() 
        return num;
    

    public void setNum(int num) 
        this.num = num;

第二步：在/resources/rules下创建规则文件attributes-rules.drl

package rules;

import com.zzg.model.AttributesEnabledEntity;

/*
 用于测试Drools 属性:enabled
*/

//测试enabled
rule "rule_attributes_enabled"
    enabled false
    when
        AttributesEnabledEntity(num > 10)
    then
        System.out.println("规则rule_attributes_enabled触发");
end

第三步：编写单元测试

 @Test
    public void test4() 
        // 第一步
        KieServices kieServices = KieServices.Factory.get();
        // 第二步
        KieContainer kieContainer = kieServices.getKieClasspathContainer();
        // 第三步
        KieSession kieSession = kieContainer.newKieSession();
        // 业务对象
        AttributesEnabledEntity enabledEntity = new AttributesEnabledEntity();
        enabledEntity.setNum(11);
        // 第四步
        kieSession.insert(enabledEntity);
        // 第五步：执行规则引擎
        kieSession.fireAllRules();
        // 第六步：关闭session
        kieSession.dispose();

dialect属性

dialect属性用于指定当前规则使用的语言类型，取值为java和mvel，默认值为java。

注：mvel是一种基于java语法的表达式语言。

虽然mvel吸收了大量的java语法，但作为一个表达式语言，还是有着很多重要的不同之处，以达到更高的效率，比如：mvel像正则表达式一样，有直接支持集合、数组和字符串匹配的操作符。

除了表达式语言外，mvel还提供了用来配置和构造字符串的模板语言。

mvel2.x表达式包含以下部分的内容：属性表达式，布尔表达式，方法调用，变量赋值，函数定义

salience属性

salience属性用于指定规则的执行优先级，取值类型为Integer。数值越大越优先执行。每个规则都有一个默认的执行顺序，如果不设置salience属性，规则体的执行顺序为由上到下。

attributes-rules.drl文件添加如下内容：

/*
 用于测试Drools 属性:salience
*/

rule "rule_attributes_salience_1"
    salience 10
    when
        AttributesEnabledEntity(flag == true)
    then
        System.out.println("规则 rule_attributes_salience_1 触发");
end

rule "rule_attributes_salience_2"
    salience 20
    when
        AttributesEnabledEntity(flag == true)
    then
        System.out.println("规则 rule_attributes_salience_2 触发");
end

rule "rule_attributes_salience_3"
    salience 1
    when
        AttributesEnabledEntity(flag == true)
    then
        System.out.println("规则 rule_attributes_salience_3 触发");
end

AttributesEnabledEntity 类新增boolean 类型(flag字段)

 private boolean flag;

效果截图:

10:39:16.506 [main] DEBUG org.drools.core.common.DefaultAgenda - State was INACTIVE is now FIRING_ALL_RULES
规则 rule_attributes_salience_2 触发
规则 rule_attributes_salience_1 触发
规则 rule_attributes_salience_3 触发

no-loop属性

no-loop属性用于防止死循环，当规则通过update之类的函数修改了Fact对象时，可能使当前规则再次被激活从而导致死循环。取值类型为Boolean，默认值为false。测试步骤如下：

attributes-rules.drl文件添加如下内容：

/*
 用于测试Drools 属性:no-loop
*/

rule "rule_attributes_noloop"
    //no-loop true
    when
        $attributesNoLoopEntity:AttributesEnabledEntity(num > 1)
    then
        update($attributesNoLoopEntity)
        System.out.println("规则 rule_attributes_noloop 触发");
end

第二步：编写单元测试

   @Test
    public void test4() 
        // 第一步
        KieServices kieServices = KieServices.Factory.get();
        // 第二步
        KieContainer kieContainer = kieServices.getKieClasspathContainer();
        // 第三步
        KieSession kieSession = kieContainer.newKieSession();
        // 业务对象
        AttributesEnabledEntity enabledEntity = new AttributesEnabledEntity();
        enabledEntity.setNum(11);
        enabledEntity.setFlag(true);
        // 第四步
        kieSession.insert(enabledEntity);
        // 第五步：执行规则引擎
        kieSession.fireAllRules();
        // 第六步：关闭session
        kieSession.dispose();

通过控制台可以看到，由于我们没有设置no-loop属性的值，所以发生了死循环。接下来设置no-loop的值为true再次测试则不会发生死循环。

lock-on-active属性

lock-on-active这个属性，可以限制当前规则只会被执行一次，包括当前规则的重复执行不是本身触发的。取值类型为Boolean，默认值为false。测试步骤如下：

attributes-rules.drl文件添加如下内容：

/*
 用于测试Drools 属性:lock-on-active
*/

rule "rule_attributes_lock_on_active_1"
    no-loop true
    when
        $attributesLockOnActiveEntity:AttributesEnabledEntity(num > 1)
    then
        update($attributesLockOnActiveEntity)
        System.out.println("规则 rule_attributes_lock_on_active_1 触发");
end

rule "rule_attributes_lock_on_active_2"
    no-loop true
    lock-on-active true
    when
        $attributesLockOnActiveEntity:AttributesEnabledEntity(num > 1)
    then
        update($attributesLockOnActiveEntity)
        System.out.println("规则 rule_attributes_lock_on_active_2 触发");
end

编写单元测试:

   @Test
    public void test4() 
        // 第一步
        KieServices kieServices = KieServices.Factory.get();
        // 第二步
        KieContainer kieContainer = kieServices.getKieClasspathContainer();
        // 第三步
        KieSession kieSession = kieContainer.newKieSession();
        // 业务对象
        AttributesEnabledEntity enabledEntity = new AttributesEnabledEntity();
        enabledEntity.setNum(11);
        enabledEntity.setFlag(true);
        // 第四步
        kieSession.insert(enabledEntity);
        // 第五步：执行规则引擎
        kieSession.fireAllRules();
        // 第六步：关闭session
        kieSession.dispose();

no-loop的作用是限制因为modify等更新操作导致规则重复执行，但是有一个限定条件，是当前规则中进行更新导致当前规则重复执行。而不是防止其他规则更新相同的fact对象，导致当前规则更新,lock-on-active可以看作是no-loop的加强版，不仅能限制自己的更新，还能限制别人的更新造成的死循环。

activation-group属性

activation-group属性是指激活分组，取值为String类型。具有相同分组名称的规则只能有一个规则被触发。

第一步：编写规则文件

package rules
import com.zzg.model.AttributesActivationGroupEntity

/*
 用于测试Drools 属性: activation-group
*/

rule "rule_attributes_activation_group_1"
    activation-group "customGroup"
    when
        $attributesActivationGroupEntity:AttributesActivationGroupEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_activation_group_1 触发");
end

rule "rule_attributes_activation_group_2"
    activation-group "customGroup"
    when
        $attributesActivationGroupEntity:AttributesActivationGroupEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_activation_group_2 触发");
end

编写单元测试:

 // 第一步
 KieServices kieServices = KieServices.Factory.get();
 // 第二步
 KieContainer kieContainer = kieServices.getKieClasspathContainer();
 // 第三步
 KieSession kieSession = kieContainer.newKieSession(); 
 // 业务对象
AttributesActivationGroupEntity attributesActivationGroupEntity = new 
 AttributesActivationGroupEntity();
        attributesActivationGroupEntity.setNum(20);

 kieSession.insert(attributesActivationGroupEntity);
  // 第五步：执行规则引擎
  kieSession.fireAllRules();
  // 第六步：关闭session
  kieSession.dispose();

通过控制台可以发现，上面的两个规则因为属于同一个分组，所以只有一个触发了。同一个分组中的多个规则如果都能够匹配成功，具体哪一个最终能够被触发可以通过salience属性确定。

agenda-group属性

agenda-group属性为议程分组，属于另一种可控的规则执行方式。用户可以通过设置agenda-group来控制规则的执行，只有获取焦点的组中的规则才会被触发。

第一步：编写规则文件

package rules
import com.zzg.model.AttributesAgendaGroupEntity

/*
 用于测试Drools 属性: agenda-group
*/

rule "rule_attributes_agenda_group_1"
    agenda-group "customAgendaGroup1"
    when
        $attributesAgendaGroupEntity:AttributesAgendaGroupEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_agenda_group_1 触发");
end

rule "rule_attributes_agenda_group_2"
    agenda-group "customAgendaGroup1"
    when
        $attributesAgendaGroupEntity:AttributesAgendaGroupEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_agenda_group_2 触发");
end


rule "rule_attributes_activation_group_3"
    agenda-group "customAgendaGroup2"
    when
        $attributesAgendaGroupEntity:AttributesAgendaGroupEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_activation_group_3 触发");
end

rule "rule_attributes_agenda_group_4"
    agenda-group "customAgendaGroup2"
    when
        $attributesAgendaGroupEntity:AttributesAgendaGroupEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_agenda_group_4 触发");
end

编写单元测试:

 // 第一步
 KieServices kieServices = KieServices.Factory.get();
 // 第二步
KieContainer kieContainer = kieServices.getKieClasspathContainer();
// 第三步
KieSession kieSession = kieContainer.newKieSession();
// 业务对象 
AttributesAgendaGroupEntity attributesAgendaGroupEntity = new 
 AttributesAgendaGroupEntity();
        attributesAgendaGroupEntity.setNum(20);

 kieSession.insert(attributesAgendaGroupEntity);
 kieSession.getAgenda().getAgendaGroup("customAgendaGroup2").setFocus();
  // 第五步：执行规则引擎
  kieSession.fireAllRules();
  // 第六步：关闭session
  kieSession.dispose();

通过控制台可以看到，只有获取焦点的分组中的规则才会触发。与activation-group不同的是，activation-group定义的分组中只能够有一个规则可以被触发，而agenda-group分组中的多个规则都可以被触发。

auto-focus属性

auto-focus属性为自动获取焦点，取值类型为Boolean，默认值为false。一般结合agenda-group属性使用，当一个议程分组未获取焦点时，可以设置auto-focus属性来控制。

第一步：编写规则文件

package rules
import com.zzg.model.AttributesAutoFocusEntity

/*
 用于测试Drools 属性: auto-focus
*/

rule "rule_attributes_auto_focus_1"
    agenda-group "customAgendaGroup1"
    when
        $attributesAutoFocusEntity:AttributesAutoFocusEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_auto_focus_1 触发");
end

rule "rule_attributes_auto_focus_2"
    agenda-group "customAgendaGroup1"
    when
        $attributesAutoFocusEntity:AttributesAutoFocusEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_auto_focus_2 触发");
end

rule "rule_attributes_auto_focus_3"
    agenda-group "customAgendaGroup2"
//    auto-focus true
    when
        $attributesAutoFocusEntity:AttributesAutoFocusEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_auto_focus_3 触发");
end

rule "rule_attributes_auto_focus_4"
    agenda-group "customAgendaGroup2"
    when
        $attributesAutoFocusEntity:AttributesAutoFocusEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_auto_focus_4 触发");
end

编写单元测试

 // 第一步
 KieServices kieServices = KieServices.Factory.get();
 // 第二步
KieContainer kieContainer = kieServices.getKieClasspathContainer();
// 第三步
KieSession kieSession = kieContainer.newKieSession();
// 业务对象 
AttributesAutoFocusEntity attributesAutoFocusEntity = new AttributesAutoFocusEntity();
        attributesAutoFocusEntity.setNum(20);

 kieSession.insert(attributesAutoFocusEntity);
  // 第五步：执行规则引擎
  kieSession.fireAllRules();
  // 第六步：关闭session
  kieSession.dispose();

通过控制台可以看到，设置auto-focus属性为true的规则都触发了。

注意：同一个组，只要有个设置auto-focus true 其他的设置不设置都无所谓啦。都会起作用的。

timer属性

timer属性可以通过定时器的方式指定规则执行的时间，使用方式有两种：

方式一：timer (int: ?)

此种方式遵循java.util.Timer对象的使用方式，第一个参数表示几秒后执行，第二个参数表示每隔几秒执行一次，第二个参数为可选。

方式二：timer(cron: )

此种方式使用标准的unix cron表达式的使用方式来定义规则执行的时间。

第一步：编写规则文件

package rules
import com.zzg.model.AttributesTimerEntity

/*
 用于测试Drools 属性: timer
*/

rule "rule_attributes_timer_1"
    timer(5s 2s)
    when
        $attributesTimerEntity:AttributesTimerEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_timer_1 触发");
end

rule "rule_attributes_timer_2"
    timer(cron:0/1 * * * * ?)
    when
        $attributesTimerEntity:AttributesTimerEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_timer_2 触发");
end

编写单元测试:

 // 第一步
 KieServices kieServices = KieServices.Factory.get();
 // 第二步
KieContainer kieContainer = kieServices.getKieClasspathContainer();
// 第三步
KieSession kieSession = kieContainer.newKieSession();
// 业务对象 
AttributesTimerEntity attributesTimerEntity = new AttributesTimerEntity();
        attributesTimerEntity.setNum(20);

        kieSession.insert(attributesTimerEntity);
        kieSession.fireUntilHalt();

        Thread.sleep(10000);
        kieSession.halt();
// 关闭
        kieSession.dispose();

注意：如果规则中有用到了timer属性，匹配规则需要调用kieSession.fireUntilHalt();这里涉及一个规则引擎的执行模式和线程问题，关于具体细节，我们后续讨论。

date-effective属性

date-effective属性用于指定规则的生效时间，即只有当前系统时间大于等于设置的时间或者日期规则才有可能触发。默认日期格式为：dd-MMM-yyyy。用户也可以自定义日期格式。

第一步：编写规则文件

package rules
import com.zzg.model.AttributesDateEffectiveEntity

/*
 用于测试Drools 属性: date-effective
*/

rule "rule_attributes_date_effective"
//    date-effective "20-七月-2021"
    date-effective "2021-02-20"
    when
        $attributesDateEffectiveEntity:AttributesDateEffectiveEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_date_effective 触发");
end

编写单元测试

// 第一步
KieServices kieServices = KieServices.Factory.get();
// 第二步
KieContainer kieContainer = kieServices.getKieClasspathContainer();
// 第三步
KieSession kieSession = kieContainer.newKieSession();
// 业务对象
AttributesDateEffectiveEntity attributesDateEffectiveEntity = new AttributesDateEffectiveEntity();
        attributesDateEffectiveEntity.setNum(20);

kieSession.insert(attributesDateEffectiveEntity);
// 第五步：执行规则引擎
kieSession.fireAllRules();
// 第六步：关闭session
kieSession.dispose();

注意：需要在VM参数上加上日期格式:-Ddrools.dateformat=yyyy-MM-dd，在生产环境所在规则引擎的JVM设置中，也需要设置此参数，以保证开发和生产的一致性。

date-expires属性

date-expires属性用于指定规则的失效时间，即只有当前系统时间小于设置的时间或者日期规则才有可能触发。默认日期格式为：dd-MMM-yyyy。用户也可以自定义日期格式。

第一步：编写规则文件/resource/rules/dateexpires.drl

package rules
import com.zzg.model.AttributesDateExpiresEntity

/*
 用于测试Drools 属性: date-expires
*/

rule "rule_attributes_date_expires"
    date-expires "2021-06-20"
    when
        $attributesDateExpiresEntity:AttributesDateExpiresEntity(num > 1)
    then
        System.out.println("规则 rule_attributes_date_expires 触发");
end

编写单元测试

// 第一步
KieServices kieServices = KieServices.Factory.get();
// 第二步
KieContainer kieContainer = kieServices.getKieClasspathContainer();
// 第三步
KieSession kieSession = kieContainer.newKieSession();
// 业务对象
AttributesDateExpiresEntity attributesDateExpiresEntity = new AttributesDateExpiresEntity();
    attributesDateExpiresEntity.setNum(20);

kieSession.insert(attributesDateExpiresEntity);

// 第五步：执行规则引擎
  kieSession.fireAllRules();
  // 第六步：关闭session
  kieSession.dispose();

注意：需要在VM参数上加上日期格式:-Ddrools.dateformat=yyyy-MM-dd，在生产环境所在规则引擎的JVM设置中，也需要设置此参数，以保证开发和生产的一致性。

六、Drools高级语法

我们已经知道了一套完整的规则文件内容构成如下：

关键字	描述
package	包名，只限于逻辑上的管理，同一个包名下的查询或者函数可以直接调用
import	用于导入类或者静态方法
global	全局变量
function	自定义函数
query	查询
rule end	规则体

global全局变量

global关键字用于在规则文件中定义全局变量，它可以让应用程序的对象在规则文件中能够被访问。可以用来为规则文件提供数据或服务。

语法结构为：global 对象类型对象名称

在使用global定义的全局变量时有两点需要注意：

1、如果对象类型为包装类型时，在一个规则中改变了global的值，那么只针对当前规则有效，对其他规则中的global不会有影响。可以理解为它是当前规则代码中的global副本，规则内部修改不会影响全局的使用。

2、如果对象类型为集合类型或JavaBean时，在一个规则中改变了global的值，对java代码和所有规则都有效。

第一步：编写规则文件

package rules
import com.zzg.model.GlobalEntity

/*
 用于测试Drools 全局变量 : global
*/

global java.lang.Integer globalCount
global java.util.List globalList

rule "rule_global_1"
    when
        $globalEntity:GlobalEntity(num > 1)
    then
        System.out.println("规则 rule_global_1 开始...");
        globalCount++ ;
        globalList.add("张三");
        globalList.add("李四");

        System.out.println(globalCount);
        System.out.println(globalList);
        System.out.println("规则 rule_global_1 结束...");
end

rule "rule_global_2"
    when
        $globalEntity:GlobalEntity(num > 1)
    then
        System.out.println("规则 rule_global_2 开始...");
        System.out.println(globalCount);
        System.out.println(globalList);
        System.out.println("规则 rule_global_2 结束...");
end

编写单元测试

// 第一步
 KieServices kieServices = KieServices.Factory.get();
 // 第二步
KieContainer kieContainer = kieServices.getKieClasspathContainer();
// 第三步
KieSession kieSession = kieContainer.newKieSession();
// 业务对象
GlobalEntity globalEntity = new GlobalEntity();
globalEntity.setNum(20);

ArrayList<Object> globalList = new ArrayList<>();

Integer globalCount = 10;
kieSession.setGlobal("globalCount", 10);
kieSession.setGlobal("globalList", globalList);

kieSession.insert(globalEntity);

  // 第五步：执行规则引擎
  kieSession.fireAllRules();
  // 第六步：关闭session
  kieSession.dispose();

query查询

query查询提供了一种查询working memory中符合约束条件的Fact对象的简单方法。它仅包含规则文件中的LHS部分，不用指定“when”和“then”部分并且以end结束。

语法结构如下：

query 查询的名称(可选参数)
    LHS
end

编写规则文件

package rules
import com.zzg.model.QueryEntity

/*
 用于测试Drools 方法: query
*/

//无参查询
query "query_1"
    $queryEntity:QueryEntity(age>20)
end

//有参查询
query "query_2"(Integer qAge,String qName)
    $queryEntity:QueryEntity(age > qAge && name == qName)
end

编写单元测试

 // 第一步
 KieServices kieServices = KieServices.Factory.get();
 // 第二步
KieContainer kieContainer = kieServices.getKieClasspathContainer();
// 第三步
KieSession kieSession = kieContainer.newKieSession();
// 业务对象
QueryEntity queryEntity1= new QueryEntity();
QueryEntity queryEntity2= new QueryEntity();
QueryEntity queryEntity3= new QueryEntity();

queryEntity1.setName("张三").setAge(10);
queryEntity2.setName("李四").setAge(20);
queryEntity3.setName("王五").setAge(30);


kieSession.insert(queryEntity1);
kieSession.insert(queryEntity2);
kieSession.insert(queryEntity3);

QueryResults results1 = kieSession.getQueryResults("query_1");
QueryResults results2 = kieSession.getQueryResults("query_2", 1, "张三");


for (QueryResultsRow queryResultsRow : results1) 
            QueryEntity queryEntity = (QueryEntity) (queryResultsRow.get("$queryEntity"));
            System.out.println(queryEntity);
        

        for (QueryResultsRow queryResultsRow : results2) 
            QueryEntity queryEntity = (QueryEntity) (queryResultsRow.get("$queryEntity"));
            System.out.println(queryEntity);
        
// 第五步：执行规则引擎
kieSession.fireAllRules();
// 第六步：关闭session
kieSession.dispose();

function函数

function关键字用于在规则文件中定义函数，就相当于java类中的方法一样。可以在规则体中调用定义的函数。使用函数的好处是可以将业务逻辑集中放置在一个地方，根据需要可以对函数进行修改。

函数定义的语法结构如下：

function 返回值类型 函数名(可选参数)    //逻辑代码

编写规则文件/resources/rules/function.drl

package rules
import com.zzg.model.FunctionEntity

/*
 用于测试Drools 方法: function
*/

//定义一个 假发 方法
function Integer add(Integer num)
    return num+10;


rule  "function"
    when
        $functionEntity:FunctionEntity(num>20)
    then
        Integer result = add($functionEntity.getNum());
        System.out.println(result);
end

编写单元测试

drools规则引擎环境搭建(代码片段)

一、关于drools规则引擎前面写过一篇Drools规则引擎相关的文章，这篇文章主要记录一下规则引擎的环境搭建和简单示例。不熟悉drools的朋友可以看看这篇文章：自己写个Drools文件语法检查工具——栈的应用之编译器检测语法错误... 查看详情

什么是spark？通俗易懂，一文读懂(代码片段)

...8;large-scaladata）**处理的**统一（unified）**分析引擎。*分析引擎(计算引擎):我们目前接触的引擎有:MapReduce分布式计算引擎Spark分布式内存计算引擎计算引擎:通用的可以执行开发人员提供的业务代码的一种框架.Spa 查看详情

规则引擎drools的使用(代码片段)

引入maven<dependency><groupId>org.drools</groupId><artifactId>drools-templates</artifactId><version>7.14.0.Final</version></dependency><dependency>& 查看详情

drools规则引擎入门指南(代码片段)

本篇博客主要讲解Drools常用的属性以及函数属性首先我们在resourcesules文件夹下创建一个Property.drl，还有一个DroolsApplicationPropertyTests1.salience优先级salience属性的值默认为0，它的值越大执行的优先级就越高,看如下代码在执行的时候... 查看详情

35activiti整合规则引擎drools(代码片段)

喜欢关注公众号：java乐园日常生活是由规则驱动的。红灯停绿灯行，这是我们的交通规则；我们站着往上跳，最终还是要落下来，这是地球的引力规则。规则在生活中无处不在。软件开发中我们也需要规则，满足什么规则应该... 查看详情

规则引擎drools示例：个人所得税计算器信用卡申请保险产品准入规则(代码片段)

...一、Drools实战1.1个人所得税计算器1.1.1名词解释1.1.2计算规则1.1.3实现步骤1.2信用卡申请1.2.1计算规则1.2.2实现步骤1.3保险产品准入规则1.3.1决策表1.3.2规则介绍1.3.3实现步骤一、Drools实战1.1个人所得税计算器本小节我们需要通过Drool... 查看详情

drools规则引擎初探(代码片段)

...么Drools是为Java量身定制的基于Charles Forgy的RETE算法的规则引擎的实现。具有了OO接口的RETE,使得商业规则有了更自然的表达。Rule是什么呢？一条规则是对商业知识的编码。一条规则有 attributes ，一个 LeftHandSide&... 查看详情

drools规则引擎中易混淆语法分析_循环触发导致死循环分析(代码片段)

...开发与测试阶段解决了，未波及到prod。首先看这样两条规则/***规则1_set默认利率*/rule"rate_default"no-looptruewhen$request:AmountRateRequest(calculateEnum==CalculateEnum.INTEREST||calculateEnum==CalculateEnu 查看详情

drools整合springboot整合drools测试例子--个税计算器规则(代码片段)

规则引擎，主要作用，就是将规则与java代码分离，可通过修改规则实时生效。让非java程序员，只要熟悉业务，也可以写规则。规则引擎主要用在一些，打折、风控前置、后置、结算等模块地方。新建一个droolsdemo的maven工程。pom.... 查看详情

linuxshell脚本一文读懂(代码片段)

...什么是shell1.1第一个shell脚本 2、Shell变量2.1Shell变量命名规则2.2Shell变量类型2.2.1用户变量2.2.2系统变量2.2.3环境变量3、Shell参数传递3.1命令行式参数传递3.2 getopts参数传递 4、Shell数组4.1 关联数组（等同于键值对Map）5、... 查看详情

java规则引擎--drools

Drools是一个基于java的规则引擎，开源的，可以将复杂多变的规则从硬编码中解放出来，以规则脚本的形式存放在文件中，使得规则的变更不需要修正代码重启机器就可以立即在线上环境生效。本文所使用的demo已上传 http... 查看详情

drools7hellowrold入门详细步骤--系列01课(代码片段)

一、什么叫规则引擎？规则---》写在文档上引擎---》在java代码上，引用这个文档上的规则二、drools规则引擎有什么用？简单来说就是将多变的规则，从业务代码中剥离出来（当规则变了之后，不用修改代码，而是修改一份文本... 查看详情

java开源的规则引擎drools电商行业实战（含完整代码）(代码片段)

...量是动态的，另外考虑到扩展性，满足将来业务规则的增长，不只是限制领取数需要新加其他条件，为了满足不断变化的业务场景，经分析后选用规则引擎Drools来实现。本场Chat通过一个电商行业的领取优惠券... 查看详情

googleaviator——轻量级java表达式引擎实战(代码片段)

...擎技术及比较Drools简介Drools（JBossRules）是一个开源业务规则引擎，符合业内标准，速度快、效率高。业务分析师或审核人员可以利用它轻松查看业务规则，从而检验是否已编码的规则执行了所需的业务规则。除了应用了Rete核心... 查看详情

drools简单应用(代码片段)

...事。　　最近在对项目的积分模块进行改造的时候想到了规则引擎，使用规则引擎处理复杂而且多变的业务逻辑有其非常大的优势，包括实时更新、性能等方面。不多说，直接上代码：1、第一步先写好工具类，有了工具类，只... 查看详情

java规则引擎drools急速入门

文章目录1.Drools规则引擎简介2.DroolsAPI开发步骤3.SpringBoot整合Drools案例4.Drools基础语法5.Drools条件语法部分6.Drools结果操作部分7.Drools内置属性部分8.Drools高级语法... 查看详情

一文读懂简单查询代价估算(代码片段)

...字，转化成相应的标识符(Tokens)。语法分析：语法规则描述文件*.y经YACC工具编译生成gram.c，再由C编译器生成可执行的语法分析器。基本功能就是将一堆标识符(Tokens)根据设定的语法规则，转化成原始语法树。分析... 查看详情

makefile入门(超详细一文读懂)(代码片段)

...是落在目标依赖上，最广泛使用的是GNUmake。2、语法规则目标...:依赖... 命令1 命查看详情