经典需求与场景

需求

传统做法-if

传统做法-策略

问题？

规则引擎

概念

起源

原理--基于 rete 算法的规则引擎

规则引擎应用场景

Drools 介绍

消费赠送积分案例

第一步：创建工程，引入jar

创建 drools 自动配置类

订单实体类

规则引擎文件

客户端

drools 开发小结

drools 组成

经典需求与场景

需求

商城系统消费赠送积分

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

传统做法-if

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);
}

传统做法-策略

interface Strategy {addScore(int num1,int num2);
}class Strategy1 {addScore(int num1);
}
......................
interface StrategyN {addScore(int num1);
}class Environment {private Strategy strategy;public Environment(Strategy strategy) {this.strategy = strategy;}public int addScore(int num1) {return strategy.addScore(num1);}
}

问题？

以上解决方法问题思考：

如果需求变更，积分层次结构增加，积分比例调整？

数据库？

遇到的问题瓶颈：

第一，我们要简化if else结构,让业务逻辑和数据分离！

第二，分离出的业务逻辑必须要易于编写，至少单独编写这些业务逻辑，要比写代码快！

第三，分离出的业务逻辑必须要比原来的代码更容易读懂！

第四，分离出的业务逻辑必须比原来的易于维护，至少改动这些逻辑，应用程序不用重启！

规则引擎

概念

规则引擎由推理引擎发展而来，是一种嵌入在应用程序中的组件，实现了将业务决策从应用程序代码中分离出来，并使用预定义的语义模块编写业务决策。接受数据输入，解释业务规则，并根据业务规则做出业务决策

需要注意的是规则引擎并不是一个具体的技术框架，而是指的一类系统，即业务规则管理系统。目前市面上具体的规则引擎产品有：drools、VisualRules、iLog等

在很多企业的 IT 业务系统中，经常会有大量的业务规则配置，而且随着企业管理者的决策变化，这些业务规则也会随之发生更改。为了适应这样的需求，我们的 IT 业务系统应该能快速且低成本的更新。适应这样的需求，一般的作法是将业务规则的配置单独拿出来，使之与业务系统保持低耦合。目前，实现这样的功能的程序，已经被开发成为规则引擎。

起源

原理--基于 rete 算法的规则引擎

原理

在 AI 领域，产生式系统是一个很重要的理论，产生式推理分为正向推理和逆向推理产生式，其规则的一般形式是：IF 条件 THEN 操作。rete 算法是实现产生式系统中正向推理的高效模式匹配算法，通过形成一个 rete 网络进行模式匹配，利用基于规则的系统的时间冗余性和结构相似性特征，提高系统模式匹配效率

正向推理（Forward-Chaining）和反向推理（Backward-Chaining）

（1）正向推理也叫演绎法，由事实驱动，从一个初始的事实出发，不断地从应用规则得出结论。首先在候选队列中选择一条规则作为启用规则进行推理，记录其结论作为下一步推理的证据。如此重复这个过程，直到再无可用规则可被选用或者求得了所要求的解为止。

（2）反向推理也叫归纳法，由目标驱动，首先提出某个假设，然后寻找支持该假设的证据，若所需的证据都能找到，说明原假设是正确的，若无论如何都找不到所需要的证据，则说明原假设不成立，此时需要另作新的假设。

rete算法

Rete 算法最初是由卡内基梅隆大学的 Charles L.Forgy 博士在 1974 年发表的论文中所阐述的算法 , 该算法提供了专家系统的一个高效实现。自 Rete 算法提出以后 , 它就被用到一些大型的规则系统中 , 像 ILog、Jess、JBoss Rules 等都是基于 RETE 算法的规则引擎。

Rete 在拉丁语中译为”net”，即网络。Rete 匹配算法是一种进行大量模式集合和大量对象集合间比较的高效方法，通过网络筛选的方法找出所有匹配各个模式的对象和规则。

其核心思想是将分离的匹配项根据内容动态构造匹配树，以达到显著降低计算量的效果。Rete 算法可以被分为两个部分：规则编译和规则执行。当 Rete 算法进行事实的断言时，包含三个阶段：匹配、选择和执行，称做 match-select-act cycle。

规则引擎应用场景

Drools 介绍

Drools 具有一个易于访问企业策略、易于调整以及易于管理的开源业务规则引擎，符合业内标准，速度快、效率高。业务分析师或审核人员可以利用它轻松查看业务规则，从而检验已编码的规则是否执行了所需的业务规则。其前身是 Codehaus 的一个开源项目叫 Drools，后被纳入 JBoss 门下，更名为 JBoss Rules，成为了 JBoss 应用服务器的规则引擎。

Drools 被分为两个主要的部分：编译和运行时。编译是将规则描述文件按 ANTLR 3 语法进行解析，对语法进行正确性的检查，然后产生一种中间结构“descr”，descr 用 AST 来描述规则。目前，Drools 支持四种规则描述文件，分别是：drl 文件、 xls 文件、brl 文件和 dsl 文件，其中，常用的描述文件是 drl 文件和 xls 文件，而 xls 文件更易于维护，更直观，更为被业务人员所理解。运行时是将 AST传到 PackageBuilder，由 PackagBuilder来产生 RuleBase，它包含了一个或多个 Package 对象。

消费赠送积分案例

第一步：创建工程，引入jar

由于当前java开发，普通使用springboot ，本课程以springboot为基本框架演示

jar 依赖，注意，排除spring相关依赖

<!-- 规则引擎 --><dependency><groupId>org.kie</groupId><artifactId>kie-spring</artifactId><version>${drools.version}</version><exclusions><exclusion><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId></exclusion><exclusion><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId></exclusion><exclusion><groupId>org.springframework</groupId><artifactId>spring-core</artifactId></exclusion><exclusion><groupId>org.springframework</groupId><artifactId>spring-context</artifactId></exclusion></exclusions></dependency>

创建 drools 自动配置类

drools 在spring 或者springboot中用法一样，其实就是创建好一些bean

package com.mashibing.drools.config;import org.kie.api.KieBase;
import org.kie.api.KieServices;
import org.kie.api.builder.*;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.internal.io.ResourceFactory;
import org.kie.spring.KModuleBeanFactoryPostProcessor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;import java.io.IOException;/*** <p> 规则引擎自动配置类 </p>* @author 孙志强* @date 2019/9/10 11:20*/
@Configuration
public class DroolsAutoConfiguration {private static final String RULES_PATH = "rules/";private KieServices getKieServices() {return KieServices.Factory.get();}@Bean@ConditionalOnMissingBean(KieFileSystem.class)public KieFileSystem kieFileSystem() throws IOException {KieFileSystem kieFileSystem = getKieServices().newKieFileSystem();for (Resource file : getRuleFiles()) {kieFileSystem.write(ResourceFactory.newClassPathResource(RULES_PATH + file.getFilename(), "UTF-8"));}return kieFileSystem;}private Resource[] getRuleFiles() throws IOException {ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();return resourcePatternResolver.getResources("classpath*:" + RULES_PATH + "**/*.*");}@Bean@ConditionalOnMissingBean(KieContainer.class)public KieContainer kieContainer() throws IOException {final KieRepository kieRepository = getKieServices().getRepository();kieRepository.addKieModule(() -> kieRepository.getDefaultReleaseId());KieBuilder kieBuilder = getKieServices().newKieBuilder(kieFileSystem());kieBuilder.buildAll();KieContainer kieContainer = getKieServices().newKieContainer(kieRepository.getDefaultReleaseId());return kieContainer;}@Bean@ConditionalOnMissingBean(KieBase.class)public KieBase kieBase() throws IOException {return kieContainer().getKieBase();}}

订单实体类

@Data
@Accessors(chain = true)
public class Order {/*** 订单原价金额*/private int price;/***下单人*/private User user;/***积分*/private int score;/*** 下单日期*/private Date bookingDate;
}

规则引擎文件

package rulesimport com.mashibing.drools.entity.Orderrule "zero"no-loop truelock-on-active truesalience 1when$s : Order(amout <= 100)then$s.setScore(0);update($s);
endrule "add100"no-loop truelock-on-active truesalience 1when$s : Order(amout > 100 && amout <= 500)then$s.setScore(100);update($s);
endrule "add500"no-loop truelock-on-active truesalience 1when$s : Order(amout > 500 && amout <= 1000)then$s.setScore(500);update($s);
endrule "add1000"no-loop truelock-on-active truesalience 1when$s : Order(amout > 1000)then$s.setScore(1000);update($s);
end

客户端

/*** 需求* 计算额外积分金额 规则如下: 订单原价金额* 100以下, 不加分* 100-500 加100分* 500-1000 加500分* 1000 以上 加1000分*/
public class DroolsOrderTests extends DroolsApplicationTests {@Resourceprivate KieContainer kieContainer;@Testpublic void Test() throws Exception {List<Order> orderList = getInitData();for (Order order : orderList) {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);}}}@Testpublic void droolsOrderTest() throws Exception {KieSession kieSession = kieContainer.newKieSession();List<Order> orderList = getInitData();for (Order order: orderList) {// 1-规则引擎处理逻辑kieSession.insert(order);kieSession.fireAllRules();// 2-执行完规则后, 执行相关的逻辑addScore(order);}kieSession.dispose();}private static void addScore(Order o){System.out.println("用户" + o.getUser().getName() + "享受额外增加积分: " + o.getScore());}private static List<Order> getInitData() throws Exception {List<Order> orderList = new ArrayList<>();DateFormat df = new SimpleDateFormat("yyyy-MM-dd");{Order order = new Order();order.setAmout(80);order.setBookingDate(df.parse("2015-07-01"));User user = new User();user.setLevel(1);user.setName("Name1");order.setUser(user);order.setScore(111);orderList.add(order);}{Order order = new Order();order.setAmout(200);order.setBookingDate(df.parse("2015-07-02"));User user = new User();user.setLevel(2);user.setName("Name2");order.setUser(user);orderList.add(order);}{Order order = new Order();order.setAmout(800);order.setBookingDate(df.parse("2015-07-03"));User user = new User();user.setLevel(3);user.setName("Name3");order.setUser(user);orderList.add(order);}{Order order = new Order();order.setAmout(1500);order.setBookingDate(df.parse("2015-07-04"));User user = new User();user.setLevel(4);user.setName("Name4");order.setUser(user);orderList.add(order);}return orderList;}
}

drools 开发小结

drools 组成

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

Working Memory（工作内存）

Rules（规则库）

Facts

Production memory

Working memory:

Agenda

如下图所示：

KIE介绍

在上述分析积分兑换的过程中，简单地使用了 "kie "开头的一些类名，Kie全称为Knowledge Is Everything，即"知识就是一切"的缩写，是Jboss一系列项目的总称。官网描述：这个名字渗透在GitHub账户和Maven POMs中。随着范围的扩大和新项目的展开，KIE（Knowledge Is Everything的缩写）被选为新的组名。KIE的名字也被用于系统的共享方面；如统一的构建、部署和使用。

规则文件开发

规则文件构成

在使用Drools时非常重要的一个工作就是编写规则文件，通常规则文件的后缀为.drl。

drl是Drools Rule Language的缩写。在规则文件中编写具体的规则内容。

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

Drools支持的规则文件，除了drl形式，还有Excel文件类型的。

规则体语法结构

规则体是规则文件内容中的重要组成部分，是进行业务规则判断、处理业务结果的部分。

规则体语法结构如下：

rule "ruleName"attributeswhenLHS thenRHS
end

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

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

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

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

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

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

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

注释

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

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

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

Pattern模式匹配

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

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

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

例如我们的入门案例中：

rule "add100"no-loop truelock-on-active truesalience 1when$order : Order(price > 100 && price <= 500)then$order.setScore(100);update($s);
end

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

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

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

3、Fact对象的price属性值必须小于等于500------属性约束

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

绑定变量既可以用在对象上，也可以用在对象的属性上。例如上面的例子可以改为：

rule "add100"no-loop truelock-on-active truesalience 1when$order : Order($price:price > 100 && amopriceut <= 500)thenSystem.out.println("$price=" + $price);$s.setScore(100);update($s);
end

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

rule "add100"no-loop truelock-on-active truesalience 1when$order : Order(price > 100 && price <= 500) and$user : User(level>3)thenSystem.out.println($order.getUser());$order.setScore(100);update($order);
end

比较操作符

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

语法

contains | not contains语法结构

Object(Field[Collection/Array] contains value)

Object(Field[Collection/Array] not contains value)

memberOf | not memberOf语法结构

Object(field memberOf value[Collection/Array])

Object(field not memberOf value[Collection/Array])

matches | not matches语法结构

Object(field matches "正则表达式")

Object(field not matches "正则表达式")

contain是前面包含后面，memberOf是后面包含前面。

操作步骤

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

package com.mashibing.drools.entity;import lombok.Data;
import lombok.experimental.Accessors;import java.util.List;/*** @author sunzhiqiang23* @date 2021-06-16 21:11*/@Data
@Accessors(chain = true)
public class ComparisonEntity {/***名字集合*/private String names;/*** 字符串集合*/private List<String> list;}

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

package rules
import com.mashibing.drools.entity.ComparisonEntity/*用于测试Drools提供的比较操作符
*///测试比较操作符contains
rule "rule_comparison_contains"whenComparisonEntity(names contains "张三")ComparisonEntity(list contains names)thenSystem.out.println("规则rule_comparison_contains触发");
end//测试比较操作符not contains
rule "rule_comparison_notContains"whenComparisonEntity(names not contains "张三")ComparisonEntity(list not contains names)thenSystem.out.println("规则rule_comparison_notContains触发");
end//测试比较操作符memberOf
rule "rule_comparison_memberOf"whenComparisonEntity(names memberOf list)thenSystem.out.println("规则rule_comparison_memberOf触发");
end//测试比较操作符not memberOf
rule "rule_comparison_notMemberOf"whenComparisonEntity(names not memberOf list)thenSystem.out.println("规则rule_comparison_notMemberOf触发");
end//测试比较操作符matches
rule "rule_comparison_matches"whenComparisonEntity(names matches "张.*")thenSystem.out.println("规则rule_comparison_matches触发");
end//测试比较操作符not matches
rule "rule_comparison_notMatches"whenComparisonEntity(names not matches "张.*")thenSystem.out.println("规则rule_comparison_notMatches触发");
end

第三步：编写单元测试

package com.mashibing.drools.client;import com.mashibing.drools.DroolsApplicationTests;
import com.mashibing.drools.entity.ComparisonEntity;
import org.junit.jupiter.api.Test;
import org.kie.api.KieBase;
import org.kie.api.runtime.KieSession;import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;/*** @author sunzhiqiang23* @date 2021-06-17 23:46*/
public class ComparisonTest extends DroolsApplicationTests {@Resourcepublic KieBase kieBase;@Testpublic void testComparison(){KieSession kieSession = kieBase.newKieSession();ComparisonEntity comparisonEntity = new ComparisonEntity();comparisonEntity.setNames("张三");List<String> list = new ArrayList<>();list.add("张三");list.add("李四");comparisonEntity.setList(list);kieSession.insert(comparisonEntity);kieSession.fireAllRules();kieSession.dispose();}
}

执行指定规则

通过前面的案例可以看到，我们在调用规则代码时，满足条件的规则都会被执行。那么如果我们只想执行其中的某个规则如何实现呢？

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

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

关键字

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基本介绍，入门案例，基本语法

经典需求与场景

需求

传统做法-if

传统做法-策略

问题？

规则引擎

概念

起源

原理--基于 rete 算法的规则引擎

规则引擎应用场景

Drools 介绍

消费赠送积分案例

第一步： 创建工程，引入jar

创建 drools 自动配置类

订单实体类

规则引擎文件

客户端

drools 开发小结

drools 组成

相关概念说明

KIE介绍

规则文件开发

规则文件构成

规则体语法结构

注释

Pattern模式匹配

比较操作符

执行指定规则

关键字

相关文章

第一步：创建工程，引入jar