drools 介绍

最新推荐文章于 2024-05-13 14:07:37 发布

SZleoWang

最新推荐文章于 2024-05-13 14:07:37 发布

阅读量648

点赞数

分类专栏：数据分析数据清洗文章标签： linq c# 规则引擎

本文链接：https://blog.csdn.net/rdhj5566/article/details/124608449

版权

数据分析同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

数据清洗

2 篇文章 0 订阅

订阅专栏

1 .场景

1.1需求

商城系统消费赠送积分

100元以下, 不加分

100元-500元加100分

500元-1000元加500分

1000元以上加1000分

......

1.2传统做法

1.2.1 if...else

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

}

1.2.2 策略

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

}

1.2.3 问题？

以上解决方法问题思考：
如果需求变更，积分层次结构增加，积分比例调整？
数据库？

遇到的问题瓶颈：
第一，我们要简化if else结构,让业务逻辑和数据分离！
第二，分离出的业务逻辑必须要易于编写，至少单独编写这些业务逻辑，要比写代码快！
第三，分离出的业务逻辑必须要比原来的代码更容易读懂！
第四，分离出的业务逻辑必须比原来的易于维护，至少改动这些逻辑，应用程序不用重启！

2.是什么

2.1概念

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

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

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

2.2 起源

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

2.3.1 原理

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

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

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

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

2.3.2 rete算法

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

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

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

2.5 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 对象。

3 .消费赠送积分案例

上图为实际用法：

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

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

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

<artifactId>kie-spring</artifactId>

<version>${drools.version}</version>

<groupId>org.springframework</groupId>

<artifactId>spring-tx</artifactId>

</exclusion>

<groupId>org.springframework</groupId>

<artifactId>spring-beans</artifactId>

</exclusion>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

</exclusion>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

</exclusion>

</exclusions>

</dependency>

3.2 创建 drools 自动配置类

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

package com.ityml.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 ityml

* @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();

}

3.2订单实体类

@Data

@Accessors(chain = true)

public class Order {

/**

* 订单原价金额

private int price;

/**

*下单人

private User user;

/**

*积分

private int score;

/**

* 下单日期

private Date bookingDate;

}

3.3规则引擎文件

package rules

import com.ityml.drools.entity.Order

rule "zero"

no-loop true

lock-on-active true

salience 1

when

$s : Order(amout <= 100)

then

$s.setScore(0);

update($s);

end

rule "add100"

no-loop true

lock-on-active true

salience 1

when

$s : Order(amout > 100 && amout <= 500)

then

$s.setScore(100);

update($s);

end

rule "add500"

no-loop true

lock-on-active true

salience 1

when

$s : Order(amout > 500 && amout <= 1000)

then

$s.setScore(500);

update($s);

end

rule "add1000"

no-loop true

lock-on-active true

salience 1

when

$s : Order(amout > 1000)

then

$s.setScore(1000);

update($s);

end

3.4客户端

/**

* 需求

* 计算额外积分金额规则如下: 订单原价金额

* 100以下, 不加分

* 100-500 加100分

* 500-1000 加500分

* 1000 以上加1000分

public class DroolsOrderTests extends DroolsApplicationTests {

@Resource

private KieContainer kieContainer;

@Test

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

}

@Test

public 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;

}

SZleoWang

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
drools 介绍

1 .场景1.1需求商城系统消费赠送积分100元以下, 不加分 100元-500元加100分 500元-1000元加500分 1000元以上加1000分......1.2传统做法1.2.1 if...elseif (order.getAmout() <= 100){order.setScore(0);addScore(order);}else if(order.getAmout() > 100 && order.
复制链接

扫一扫