Drools规则引擎 系列教程(一)SpringBoot整合 & 快速集成上手

Drools规则引擎 系列教程(一)SpringBoot整合 & 快速集成上手

Drools规则引擎 系列教程(二)Drools规则语法 & LHS 条件

Drools规则引擎 系列教程(三)Drools规则语法 & RHS动作 & header详解

Drools规则引擎 系列教程(四)Drools 主要API & 决策表

教程代码已提交到ytooo-drools,欢迎star

1. Drools简介

什么是规则引擎

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

  简单来说包括像表单验证和动态表达式引擎这样的简单系统都可以称之为规则引擎。

为什么使用规则引擎?

  复杂企业级项目的开发以及其中随外部条件不断变化的业务规则(business logic),
迫切需要分离商业决策者的商业决策逻辑和应用开发者的技术决策,
并把这些商业决策放在中心数据库或其他统一的地方,让它们能在运行时(即商务时间)
可以动态地管理和修改从而提供软件系统的柔性和适应性。规则引擎正是应用于上述动态环境中的一种解决方法。

  企业管理者对企业级IT系统的开发有着如下的要求:
为提高效率,管理流程必须自动化,即使现代商业规则异常复杂;
市场要求业务规则经常变化,IT系统必须依据业务规则的变化快速、低成本的更新;
为了快速、低成本的更新,业务人员应能直接管理IT系统中的规则,不需要程序开发人员参与。

规则引擎优点

  • 声明式编程
  • 逻辑与数据分离
  • 速度及可测量性
  • 知识集中化
  • 工具集成
  • 解释机制
  • 易懂的规则

如何使用

开发人员在程序中使用规则引擎基本遵循以下5个典型的步骤:
  • 创建规则引擎对象;
  • 向引擎中加载规则集或更换规则集;
  • 向引擎提交需要被规则集处理的数据对象集合;
  • 命令引擎执行;
  • 导出引擎执行结果,从引擎中撤出处理过的数据。
    使用了规则引擎之后,许多涉及业务逻辑的程序代码基本被这五个典型步骤

drools

  Drools 是用 Java 语言编写的具有一个易于访问企业策略、易于调整以及易于管理的开源业务规则引擎
,其基于CHARLES FORGY’S的RETE算法
符合业内标准,速度快且效率高。 业务分析师人员或审核人员可以利用它轻松查看业务规则,
检验已编码的规则执行了所需的业务规则。

2. 使用IDEA创建简单的SpringBoot项目

新建springboot项目:

avatar

配置项目信息:

avatar

配置为web项目:

avatar

3. 添加drools相关pom依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<properties>
<java.version>1.8</java.version>
<drools.version>7.14.0.Final</drools.version>
</properties>
<dependencies>
<!-- drools依赖 -->
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-core</artifactId>
<version>${drools.version}</version>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-compiler</artifactId>
<version>${drools.version}</version>
</dependency>
<!-- 决策表 -->
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-decisiontables</artifactId>
<version>${drools.version}</version>
</dependency>
<!-- 模板 -->
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-templates</artifactId>
<version>${drools.version}</version>
</dependency>

<dependency>
<groupId>org.kie</groupId>
<artifactId>kie-api</artifactId>
<version>${drools.version}</version>
</dependency>
</dependencies>

4. 创建Kie相关 Bean 使其被spring管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
package com.ytooo.config;

import org.kie.api.KieBase;
import org.kie.api.KieServices;
import org.kie.api.builder.KieBuilder;
import org.kie.api.builder.KieFileSystem;
import org.kie.api.builder.KieModule;
import org.kie.api.builder.KieRepository;
import org.kie.api.builder.ReleaseId;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.internal.io.ResourceFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.io.Resource;

import java.io.IOException;

/**
* Created by Youdmeng on 2020/1/7 0007.
*/
@Configuration
public class KiaSessionConfig {

private static final String RULES_PATH = "rules/";

@Bean
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();
final Resource[] resources = resourcePatternResolver.getResources("classpath*:" + RULES_PATH + "**/*.*");
return resources;

}

@Bean
public KieContainer kieContainer() throws IOException {

final KieRepository kieRepository = getKieServices().getRepository();
kieRepository.addKieModule(new KieModule() {
public ReleaseId getReleaseId() {
return kieRepository.getDefaultReleaseId();
}
});

KieBuilder kieBuilder = getKieServices().newKieBuilder(kieFileSystem());
kieBuilder.buildAll();
return getKieServices().newKieContainer(kieRepository.getDefaultReleaseId());

}

private KieServices getKieServices() {
return KieServices.Factory.get();
}

@Bean
public KieBase kieBase() throws IOException {
return kieContainer().getKieBase();
}

@Bean
public KieSession kieSession() throws IOException {
return kieContainer().newKieSession();
}
}

5. 创建drl规则文件

创建 kmodule.xml配置文件来指定规则文件.drl所在路径,使用packages属性来指定规则描述文件在项目中的位置(相对于resources) (!!!舍弃!!!)

1
2
3
4
5
6
7
8
9
10
11
!!!舍弃!!!
<kmodule xmlns="http://jboss.org/kie/6.0.0/kmodule">
<kbase name="rules" packages="rules">
<ksession name="ksession-rules"/>
</kbase>
</kmodule>
!!!舍弃!!!
在此种方法下,需在获取session时指定名称 如:
KieServices ks = KieServices.Factory.get();
KieContainer kContainer = ks.getKieClasspathContainer();
return kContainer.newKieSession("ksession-rules");

使用config中 resourcePatternResolver.getResources 来定位规则路径

1
2
private static final String RULES_PATH = "rules/";
final Resource[] resources = resourcePatternResolver.getResources("classpath*:" + RULES_PATH + "**/*.*");

创建规则

1. people.drl
1
2
3
4
5
6
7
8
9
10
package com.ytooo.bean
import com.ytooo.bean.People
dialect "java"

rule "man"
when
$p : People(sex == 1 && drlType == "people")
then
System.out.println($p.getName() + "是男孩");
end
2. people2.drl
1
2
3
4
5
6
7
8
9
10
package com.ytooo.bean
import com.ytooo.bean.People
dialect "java"

rule "girl"
when
$p : People(sex == 0 && drlType == "people")
then
System.out.println($p.getName() + "是女孩");
end

drools中,规则是使用对象来匹配规则的,如上面两个规则文件,在java中执行People对象的规则时,两种规则都会触发

6. 创建实体对象People

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.ytooo.bean;
import lombok.Data;

/**
* Created by Youdmeng on 2020/1/7 0007.
*/
@Data
public class People {

private int sex;

private String name;

private String drlType;

public People(int sex, String name, String drlType) {
this.sex = sex;
this.name = name;
this.drlType = drlType;
}

public People() {
}
}

7. 创建测试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.ytooo;

import com.ytooo.bean.People;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.kie.api.runtime.KieSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest
@RunWith(SpringRunner.class)
class DroolsApplicationTests {

@Autowired
private KieSession session;

@Autowired
private KieBase kieBase;


@Test
public void people() {

People people = new People();
people.setName("达");
people.setSex(1);
people.setDrlType("people");
session.insert(people);//插入
session.fireAllRules();//执行规则
}
@AfterEach
public void runDispose() {
session.dispose();//释放资源
}
}
  • 当入参为sex为1时,程序运行结果:
    1
    达是男孩
  • 当入参为sex为0时,程序运行结果:
    1
    达是女孩

当传入其他对象时,则不会触发以上任何规则

1
2
3
4
5
6
7
8
9
10
11
12
package com.ytooo.bean;
import lombok.Data;

/**
* Created by Youdmeng on 2020/1/7 0007.
*/
@Data
public class Cat {
private int sex;

private String name;
}
新增test方法
1
2
3
4
5
6
7
8
@Test
public void cat() {
Cat cat = new Cat();
cat.setName("金");
cat.setSex(1);
session.insert(cat);//插入
session.fireAllRules();//执行规则
}

传入sex为1或0,都没有结果输出

注:

相同.drl文件中可以继承多组规则如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.ytooo.bean
import com.ytooo.bean.People
dialect "java"

rule "man"
when
$p : People(sex == 1 && drlType == "people")
then
System.out.println($p.getName() + "是男孩");
end
rule "cat"
when
$c : Cat(sex == 1 && $c.getName().equals("金"))
then
System.out.println($c.getName() + "是公的");
end




教程代码已提交到ytooo-drools,欢迎star

Drools规则引擎 系列教程(二)Drools规则语法 & LHS 条件





更多好玩好看的内容,欢迎到我的博客交流,共同进步&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;胡萝卜啵的博客