Drools规则引擎介绍
规则引擎-drools使用讲解（简单版）-Java
规则引擎-drools使⽤讲解（简单版）-Javadrools规则引擎现状：1. 运维同学（各种同学）通过后台管理界⾯直接配置相关规则，这⾥是通过输⼊框、下拉框等完成输⼊的，⾮常简单；2. 规则配置完毕后，前端请求后端，此时服务端根据参数（即规则）⽣成drl规则⽂件；3. ⽤户侧有相关请求到达时，服务端加载规则⽂件（可能是多个，⼀般⼀个⼴告、活动对应⼀个规则⽂件），并通过引擎去检查当前⽤户各种状态是否满⾜规则⽂件；4. 将所有满⾜的规则⽂件对应的⼴告、活动进⾏下发，同时更新⽤户数据；5. 完成整个drools相关流程；关于drools是⼀款标准、效率⾼、速度快的开源规则引擎，基于ReteOO算法，⽬前主要应⽤场景在⼴告、活动下发等领域⾮常多，⽐如APP的活动下发，通常都是有很多条件限制的，且各种活动层出不穷，⽆法代码穷举，⽽如果每次为了⼀个活动重新发版上线，显然是不合理的，因此通过drools将活动中变的部分抽象为⼀个个单独的规则⽂件，来屏蔽这部分的变化，使得系统不需要从代码层⾯做出改变，当然了为了更加极致的抽象，通常还需要对规则中的⼀些可配条件（⼤于、⼩于、等于、范围、次数等）也提取到数据库中，这样在现有规则不满⾜要求时，可以直接通过更改数据库的对应规则表来完善，同样不需要改代码；我们当时的需求主要就是⼴告、活动下发规则⽐较多，⼴告也是各式各样，因此去调研了drools，对drools也没有过多的挖掘其更多特性，因此还需要⼤家的指点；drools简单使⽤服务端项⽬中使⽤drools的⼏个基本步骤；step 1 -- 添加相关依赖到maven pom.xml<dependency><groupId>org.drools</groupId><artifactId>drools-core</artifactId><version>6.4.0.Final</version></dependency><dependency><groupId>org.drools</groupId><artifactId>drools-compiler</artifactId><version>6.4.0.Final</version></dependency>step 2 -- 创建实体类加载规则⽂件public class CarIllegalRules extends BaseRules{public static void main(String[] args) {try {KieServices ks = KieServices.Factory.get();KieContainer kContainer = ks.getKieClasspathContainer();KieSession ksession = kContainer.newKieSession("ksession-rules");CarIllegalRules carIllegalRules = new CarIllegalRules(10,500,10);ksession.insert(carIllegalRules);ksession.fireAllRules();System.out.println(carIllegalRules.isCan_push()+"，"+carIllegalRules.getContent());} catch (Exception e) {e.printStackTrace();}}private int illegal_count;private int illegal_money;private int illegal_points;public CarIllegalRules(int illegal_count, int illegal_money, int illegal_points) {super();this.illegal_count = illegal_count;this.illegal_money = illegal_money;this.illegal_points = illegal_points;this.param_value = "illegal_count,illegal_money,illegal_points";}@Overridepublic String toString() {return "CarIllegalRules [illegal_count=" + illegal_count + ", illegal_money=" + illegal_money+ ", illegal_points=" + illegal_points + ", can_push=" + can_push + ", content=" + content + ", tts="+ tts + "]";}public int getIllegal_count() {return illegal_count;}public void setIllegal_count(int illegal_count) {this.illegal_count = illegal_count;}public int getIllegal_money() {return illegal_money;}public void setIllegal_money(int illegal_money) {this.illegal_money = illegal_money;}public int getIllegal_points() {return illegal_points;}public void setIllegal_points(int illegal_points) {this.illegal_points = illegal_points;}}PS:main函数是⽤来测试这个类的；step 3 -- 创建DSLUtils类去执⾏相应规则public class DSLUtil {public static void fireRules(File file, Object rules) {try {KieServices kieServices = KieServices.Factory.get();KieFileSystem kfs = kieServices.newKieFileSystem();Resource resource = kieServices.getResources().newFileSystemResource(file);fire(rules, kieServices, kfs, resource);} catch (Exception e) {e.printStackTrace();}}public static void fireRules(String urlStr, Object rules) {try {KieServices kieServices = KieServices.Factory.get();KieFileSystem kfs = kieServices.newKieFileSystem();Resource resource = kieServices.getResources().newFileSystemResource(FileUtil.getFileFromUrl(urlStr));fire(rules, kieServices, kfs, resource);} catch (Exception e) {e.printStackTrace();}}private static void fire(Object commonRules, KieServices kieServices, KieFileSystem kfs, Resource resource)throws Exception {resource.setResourceType(ResourceType.DRL);kfs.write(resource);KieBuilder kieBuilder = kieServices.newKieBuilder(kfs).buildAll();if (kieBuilder.getResults().getMessages(Message.Level.ERROR).size() > 0) {throw new Exception();}KieContainer kieContainer = kieServices.newKieContainer(kieServices.getRepository().getDefaultReleaseId());KieBase kBase = kieContainer.getKieBase();KieSession ksession = kBase.newKieSession();ksession.insert(commonRules);ksession.fireAllRules();}}step 4 -- 创建⼀个类去⽣成规则⽂件⽐如⽣成 music.drl 的⾳乐规则⽂件，这⼀步是可选的，区别在于规则⽂件的⽣成是代码⽣成，还是⼈⼯⽣成，我们的项⽬中是运维同学在后台管理界⾯通过⼀些图形化输⼊框输⼊⼀些指定参数，⽽⽣成规则⽂件是服务端代码⽣成的，因此有了这部分，⽐较实⽤，⼀⽅⾯可以降低⽣成规则⽂件的门槛，任何⼈都可以做，另⼀⽅⾯也避免了⼈⼯出错的可能；public class ActivityUtil {/*** rule template string*/private static String template ="package com.aispeech.dsl\r\n\r\n" +"import {entity_package_path};\r\n\r\n" +"import {entity_package_path}.*;\r\n\r\n" +"rule \"{rule_name}\"\r\n\r\n" +"when\r\n" +"\t{instance_name}:{class_name}({rules})\r\n" +"then\r\n" +"\t{do}\r\n" +"end";private static final String AND = " && ";private static final String OR = " || ";/*** get business rule file xxx.drl* @param carActivity user info entity* @param clazz entity class* @return*/public static File createBusinessRuleFile(Car_activity carActivity, Class clazz, String[] param_texts, String[] param_values) { String ruleStr = template;String entity_package_path = (clazz+"").substring(6);String rule_name = "rule_"+carActivity.getId();String class_name = (clazz+"").substring((clazz+"").lastIndexOf(".")+1);String instance_name = class_name.toLowerCase();String rules = "";JSONArray conditionArray = JSONArray.parseArray(carActivity.getAim_condition());for(int i=0;i<conditionArray.size();i++) {JSONObject condition = conditionArray.getJSONObject(i);rules += "\r\n\t\t("+condition.getString("param")+condition.getString("operator")+condition.getString("value")+")" + AND;}rules = rules.length()>0?rules.substring(0, stIndexOf(AND)):rules;for (String param_value : param_values) {rules += "\r\n\t\t,"+param_value.toLowerCase()+":"+param_value;}String content = JSONObject.parseObject(carActivity.getContent()).getString("content");String tts = carActivity.getTts();for (int i=0;i<param_texts.length;i++) {content = content.replace("#"+param_texts[i]+"#", "\"+"+param_values[i]+"+\"");tts = tts.replace("#"+param_texts[i]+"#", "\"+"+param_values[i]+"+\"");}String _do = instance_name+".setCan_push(true);";_do += "\r\n\t" + instance_name+".setContent(\""+content+"\");";_do += "\r\n\t" + instance_name+".setTts(\""+tts+"\");";return returnFile(ruleStr, entity_package_path, rule_name, class_name, instance_name, _do, rules);}/*** @param ruleStr* @param entity_package_path* @param rule_name* @param class_name* @param instance_name* @param _do* @param rules* @return*/private static File returnFile(String ruleStr, String entity_package_path, String rule_name, String class_name,String instance_name, String _do, String rules) {ruleStr = ruleStr.replace("{entity_package_path}", entity_package_path).replace("{rule_name}", rule_name).replace("{class_name}", class_name).replace("{instance_name}", instance_name).replace("{do}", _do).replace("{rules}", rules);System.out.println(ruleStr);return FileUtil.getFileFromText(rule_name, ".drl", ruleStr);}}step 4.1 -- 通过字符串创建⽂件，给上⼀步⽤的函数public static File getFileFromText(String tempFileName, String fileTail, String text) {try {File file = File.createTempFile(tempFileName, fileTail);FileOutputStream fos = new FileOutputStream(file);fos.write(text.getBytes());if(fos!=null){fos.close();}return file;} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}return null;}step 5 -- 规则⽂件加载，并⽤以检查当前⽤户是否满⾜下发规则条件BaseRules baseRules = new CarIllegalRules(count, money, points);if(baseRules!=null) {("before fire rules:"+baseRules);DSLUtil.fireRules(ActivityUtil.createBusinessRuleFile(car_activity, baseRules.getClass(),baseRules.getParam_text().split(","), baseRules.getParam_value().split(",")), baseRules);("after fire rules:"+baseRules);if(baseRules.isCan_push()) {//In here, the rules are used to judge the success of the entity, and you can do something}}⼩结本⽂通过对drools的简单使⽤步骤的讲解，为⼤家展⽰了drools最简单的使⽤⽅式，⽽它能做到的远远不⽌看到的这些，但是基本框架是这样，⼤家可以尝试挖掘规则⽂件的⼀些⿊操作，可以对多变的业务进⾏极致的抽象，再也不⽤为了这些重新发版啦，LOL；PS：想深⼊了解的同学还是要去看看Rete算法、drools的推理机制等等，本⽂主要从该引擎的⼊门出发哈；最后⼤家可以到我的Github上看看有没有其他需要的东西，⽬前主要是⾃⼰做的机器学习项⽬、Python各种脚本⼯具、数据分析挖掘项⽬以及Follow的⼤佬、Fork的项⽬等：。
drools规则引擎用法
drools规则引擎用法
Drools是一个基于Java的规则引擎，可以将业务决策从应用程序代码中分离出来，并使用预定义的语义模块编写业务决策。
下面是使用Drools规则引擎的一般步骤：
1. 创建一个KModule配置文件，用于指定规则文件所在的目录以及默认的规则引擎等。
KModule配置文件的名称和位置都是固定的，不能更改。
2. 在KModule配置文件中，创建一个KBase元素，用于指定规则库的名称、规则文件的目录以及是否为默认规则库等。
3. 在KBase元素中，创建一个或多个KSession元素，用于指定规则执行会话的名称、是否为默认会话以及选择器等。
4. 编写规则文件，使用Drools的语法编写业务决策。
规则文件可以使用任何文本编辑器创建，并存储在指定的目录中。
5. 加载规则文件到Drools规则引擎中。
可以使用Drools提供的API进行加载，也可以在KModule配置文件中指定加载的规则文件。
6. 创建事实对象，将需要匹配的数据封装到事实对象中。
7. 将事实对象放入工作内存中，并触发规则执行。
可以使用Drools提供的API进行触发，也可以在KSession配置文件中指定触发器。
8. 规则执行后，会返回执行结果。
可以根据需要处理执行结果。
以上是使用Drools规则引擎的一般步骤，具体实现方式可能会因项目需求和开发环境而有所不同。
drools 规则
drools 规则Drools规则引擎：提高业务逻辑的可维护性和可扩展性随着业务的不断发展，业务逻辑变得越来越复杂，传统的编程方式已经无法满足业务的需求。
Drools规则引擎是一种基于规则的编程方式，它可以帮助我们更好地管理业务逻辑，提高业务的可维护性和可扩展性。
什么是Drools规则引擎？Drools规则引擎是一种基于规则的编程方式，它可以将业务逻辑抽象成规则，然后通过规则引擎来执行这些规则。
Drools规则引擎是一个开源的规则引擎，它是由JBoss社区开发的，目前已经成为了业界最流行的规则引擎之一。
Drools规则引擎的优势1. 可维护性Drools规则引擎可以将业务逻辑抽象成规则，这些规则可以被单独管理和维护。
当业务逻辑发生变化时，我们只需要修改相应的规则即可，而不需要修改整个系统的代码。
这样可以大大提高系统的可维护性。
2. 可扩展性Drools规则引擎可以将业务逻辑与系统的其他部分分离开来，这样可以使系统更加灵活和可扩展。
当我们需要添加新的业务逻辑时，只需要添加相应的规则即可，而不需要修改系统的其他部分。
这样可以大大提高系统的可扩展性。
3. 可重用性Drools规则引擎可以将业务逻辑抽象成规则，这些规则可以被多个系统共享和重用。
这样可以避免重复编写代码，提高代码的复用率。
4. 可测试性Drools规则引擎可以将业务逻辑与系统的其他部分分离开来，这样可以使业务逻辑更容易被测试。
我们可以编写单元测试来测试每个规则的正确性，这样可以大大提高系统的可测试性。
Drools规则引擎的应用场景1. 金融行业在金融行业中，Drools规则引擎可以用于风险评估、信用评估、欺诈检测等方面。
通过将业务逻辑抽象成规则，可以使系统更加灵活和可扩展，同时也可以提高系统的可维护性和可测试性。
2. 物流行业在物流行业中，Drools规则引擎可以用于路线规划、货物跟踪、异常处理等方面。
通过将业务逻辑抽象成规则，可以使系统更加灵活和可扩展，同时也可以提高系统的可维护性和可测试性。
Java各种规则引擎
Java各种规则引擎一. Drools规则引擎1.简介：Drools就是为了解决业务代码和业务规则分离的引擎。
Drools 规则是在Java 应用程序上运行的，其要执行的步骤顺序由代码确定，为了实现这一点，Drools 规则引擎将业务规则转换成执行树。
1.特性：优点：1、简化系统架构，优化应用2、提高系统的可维护性和维护成本3、方便系统的整合4、减少编写“硬代码”业务规则的成本和风险3.原理：Drools.png1.使用方式：(1)Maven 依赖：<dependencies><dependency><groupId>org.kie</groupId><artifactId>kie-api</artifactId><version>6.5.0.Final</version></dependency><dependency><groupId>org.drools</groupId><artifactId>drools-compiler</artifactId><version>6.5.0.Final</version><scope>runtime</scope></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency></dependencies>（2）新建配置文件/src/resources/META-INF/kmodule.xml <?xml version="1.0" encoding="UTF-8"?><kmodule xmlns="/kie/6.0.0/kmodule"><kbase name="rules" packages="rules"><ksession name="myAgeSession"/></kbase></kmodule>（3）新建drools规则文件/src/resources/rules/age.drl import er // 导入类dialect "mvel"rule "age" // 规则名，唯一when$user : User(age<15 || age>60) //规则的条件部分thenSystem.out.println("年龄不符合要求！");end工程搭建完毕，效果如图：项目结构.png测试用例：/*** CreateBy: haleyliu* CreateDate: 2018/12/26*/@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(locations ={"classpath*:applicationContext.xml"})public class TestUser {private static KieContainer container = null;private KieSession statefulKieSession = null;@Testpublic void test(){KieServices kieServices = KieServices.Factory.get();container = kieServices.getKieClasspathContainer();statefulKieSession = container.newKieSession("myAgeSession");User user = new User("duval yang",12);statefulKieSession.insert(user);statefulKieSession.fireAllRules();statefulKieSession.dispose();}}二.Aviator表达式求值引擎1.简介：Aviator是一个高性能、轻量级的java语言实现的表达式求值引擎，主要用于各种表达式的动态求值。
drools规则引擎用户手册
一、简介Drools规则引擎是一种基于Java的开源业务逻辑工具，它提供了一种灵活的方式来管理业务规则和逻辑。
Drools规则引擎采用了基于规则的编程方式，它允许用户在无需修改代码的情况下动态地修改业务规则。
本手册将介绍Drools规则引擎的基本概念、使用方法、实例分析等内容，帮助用户更好地理解和使用Drools规则引擎。
二、概念解析1. Drools规则引擎的基本原理Drools规则引擎基于RETE算法实现，它使用规则、事实和条件触发器来进行逻辑推理，从而实现基于规则的业务逻辑。
2. Drools规则引擎的基本组成Drools规则引擎由规则引擎、规则库、工作内存、规则引擎会话等组成。
规则引擎用于执行规则，规则库用于存储规则集，工作内存用于存储规则引擎执行时所需的数据，规则引擎会话用于管理规则引擎的执行。
3. Drools规则引擎的基本概念Drools规则引擎涉及到规则、条件、动作、模式匹配等基本概念，规则是Drools规则引擎中的主要组成部分，它由条件和动作组成。
条件是规则的触发条件，动作是规则的执行结果。
模式匹配是Drools规则引擎中用于匹配和处理事实的机制。
三、使用方法1. Drools规则引擎的安装与配置用户可以通过Maven或手动下载安装Drools规则引擎，然后根据实际需要进行相关配置，如规则库、工作内存、规则引擎会话等配置。
2. Drools规则引擎的规则编写与管理用户可以通过DRL（Drools Rule Language）语言编写规则，然后将规则保存到规则库中。
用户也可以通过Drools提供的可视化工具进行规则的可视化编写和管理。
3. Drools规则引擎的运行与测试用户可以使用JUnit等测试工具对Drools规则引擎进行测试验证，以确保规则的正确性和有效性。
四、实例分析1. 基于Drools规则引擎实现的风险评估系统以银行贷款风险评估为例，介绍如何使用Drools规则引擎实现一个简单的风险评估系统，包括规则库的编写、规则的触发和动作的执行等过程。
drools 可视化编排规则
drools 可视化编排规则Drools 是一个基于Java的规则引擎，它提供了一种可视化编排规则的方式，使得规则的管理和维护更加方便。
本文将介绍Drools的可视化编排规则的功能和使用方法。
一、Drools规则引擎简介Drools是一个开源的业务规则管理系统，它允许用户定义和管理规则，从而实现业务逻辑的灵活配置和动态调整。
Drools使用规则引擎来执行规则并产生结果，它能够快速地处理大量的数据，并根据已定义的规则进行决策和推理。
Drools规则引擎在各个领域都有广泛的应用，如金融、医疗、电信等。
二、Drools可视化编排规则的优势Drools的可视化编排规则功能使得规则的管理和维护更加直观和高效。
通过可视化界面，用户可以方便地创建、编辑和删除规则，而无需编写复杂的代码。
以下是Drools可视化编排规则的一些优势：1. 直观易用：Drools提供了一个直观的界面，用户可以通过拖拽、连接和配置规则的方式来编排规则。
无需编写复杂的代码，即可完成规则的定义和配置。
2. 高效可靠：Drools规则引擎采用了基于Rete算法的推理引擎，能够快速高效地处理大量的规则和数据。
同时，Drools还提供了丰富的规则语法和函数库，支持复杂的规则逻辑和计算。
3. 可扩展性强：Drools规则引擎支持自定义的规则模板和函数库，用户可以根据自己的需求扩展规则的功能和表达能力。
同时，Drools还支持与其他系统的集成，如数据库、Web服务等。
4. 规则重用性高：Drools规则引擎提供了规则的版本管理和共享功能，用户可以将规则定义为独立的模块，并在不同的应用中重用。
这样可以大大提高规则的复用性和维护性。
三、Drools可视化编排规则的使用方法下面将介绍一下Drools可视化编排规则的使用方法，包括规则的创建、编辑和删除等操作。
1. 创建规则：在Drools的可视化界面中，用户可以通过拖拽和连接的方式创建规则。
首先，用户需要选择一个规则节点，并将其拖拽到工作区。
Drools5规则引擎介绍
Drools5规则引擎介绍2011-7-27目录1 规则引擎介绍 (3)1.1 什么是规则引擎 (3)1.2 使用规则引擎的优势 (3)1.3 什么场景适合使用规则引擎 (3)2 Drools简介 (4)2.1 Drools简介 (4)2.2 Drools的使用场景 (4)3 Drools的工作原理 (4)3.1 规则的工作流程 (4)3.2 Rete算法总结 (5)4 Drools5的安装 (5)4.1下载drools相关的组件 (5)4.2 解压缩已下载文件并放入eclipse中 (5)4.3 查看Drools是否安装成功 (6)4.4配置drools的Runtime环境 (6)5 创建第一个示例及代码分析 (7)5.1 创建规则 (7)5.2 代码分析(规则的编译和运行) (11)5.2.1 KnowledgeBuilder (11)5.2.2 KnowledgeBase (11)5.2.3 StatefulKnowledgeSession (12)5.2.4 StatelessKnowledgeSession (13)5.2.5 Fact对象 (14)6 规则 (14)6.1 规则文件 (14)6.2 规则语言 (15)6.2.1 条件部分 (15)6.2.2 结果部分 (16)6.2.3 属性部分 (17)6.2.4 函数 (17)6.2.5 查询 (17)6.2.6 对象定义 (18)1 规则引擎介绍1.1 什么是规则引擎规则引擎是基于规则的专家系统的核心部分，主要由三部分组成：规则库(Knowledge base)+Working Memory(Fact base)+推理机(规则引擎)，规则引擎根据既定事实和知识库按照一定的算法执行推理逻辑得到正确的结果。
规则引擎由推理引擎发展而来，是一种嵌入在应用程序中的组件，实现了将业务决策从应用程序代码中分离出来，并使用预定义的语义模块编写业务决策。
drools 简单规则
drools 简单规则Drools 是一款开源的规则引擎，是基于Java语言的领域特定语言（DSL）。
它提供了一种声明式的方式来定义业务规则，并将这些规则与业务逻辑进行分离。
本篇文章将详细介绍Drools的基本概念和使用方法，以及它在业务规则管理中的应用。
# 1. Drools简介Drools是由JBoss开发的一个业务规则管理系统。
它提供了一种高效的方式来处理复杂的业务规则，并使得这些规则易于理解和维护。
Drools从2005年发布以来，在Java开发者社区中非常流行，并得到了广泛的应用。
# 2. 什么是规则引擎规则引擎是一种用于执行规则的软件组件。
规则是由业务领域专家定义的，用于指导业务逻辑如何执行的离散条件。
规则引擎将这些规则编译成可以执行的代码，并将其与应用程序集成在一起。
规则引擎使得应用程序可以以一种更加灵活和易于维护的方式对业务逻辑进行调整。
# 3. Drools基本使用使用Drools，您需要首先定义规则，然后将其编译成可执行代码，并将其嵌入到您的应用程序中。
3.1 定义规则在Drools中，规则是由一组条件和一个结果组成的。
条件是业务规则的前提，而结果是业务规则的结论。
droolsrule "Example Rule"whenperson: Person(age > 18)thenperson.setAdult(true);end以上是一个简单的例子，它定义了一个当年龄大于18岁时设置成年标记的规则。
在这个例子中，`person`表示一个Person对象，`age`表示Person 对象的一个属性，`> 18`表示条件，`person.setAdult(true)`表示结果。
3.2 编译规则在定义规则之后，需要将其编译成可执行的代码。
Drools提供了API和工具来完成这个过程。
javaKieServices kieServices = KieServices.Factory.get(); KieFileSystem kfs = kieServices.newKieFileSystem();kfs.write("src/main/resources/rules.drl", ruleContent); KieBuilder kieBuilder = kieServices.newKieBuilder(kfs).buildAll();以上是一个简单的编译规则的示例代码。
drools 规则引擎 门槛
在当今信息化的社会，企业对于业务流程的自动化和智能化需求日益增长。
在这样的背景下，规则引擎作为一种能够支持业务规则管理和执行的关键技术，扮演着至关重要的角色。
而在众多规则引擎中，drools规则引擎因其开源、灵活性强、易扩展等特点，逐渐成为了企业中热门的选择之一。
为了更好地帮助您理解和运用drools规则引擎，本文将深入探讨drools规则引擎的门槛。
一、了解drools规则引擎的基本概念我们需要了解什么是drools规则引擎。
Drools是一个基于Java的业务规则管理系统，它提供了一个业务规则管理器和一个完整的运算引擎，允许您自定义的方式管理业务规则，基于这些规则进行决策和对事件的响应。
在学习drools规则引擎时，我们需要熟悉规则、条件、动作、规则引擎的执行流程等基本概念，并理解它们之间的关系。
二、掌握drools规则引擎的基本原理了解基本概念后，我们需要深入了解drools规则引擎的基本原理。
Drools规则引擎的核心原理是基于Rete算法，它能够高效地匹配、执行规则，实现快速的规则评估和决策。
我们还需要掌握drools规则引擎的工作原理、规则引擎的扩展性、规则引擎与业务系统的集成等内容。
三、学习drools规则引擎的高级特性和应用技巧在掌握了基本原理后，我们可以进一步学习drools规则引擎的高级特性和应用技巧。
学习如何使用DSL（领域特定语言）为规则提供更高层次的抽象，学习如何使用规则库和规则模板来更加灵活地管理规则，学习如何使用规则引擎来实现复杂的业务决策等。
这些高级特性和应用技巧的掌握，能够帮助您更好地运用drools规则引擎解决实际业务问题。
总结回顾通过对drools规则引擎的门槛的全面探讨，相信您已经对drools规则引擎有了更深入的了解。
在学习和使用drools规则引擎时，需要从基本概念入手，逐步掌握其基本原理，再学习高级特性和应用技巧。
对于企业而言，合理的规则引擎选择和使用，可能将成为提升业务智能化和效率的关键一步。
Drools规则引擎框架介绍
Drools规则引擎框架介绍Drools是一种基于Java的开源规则引擎框架，用于处理和管理复杂业务规则。
它提供了一种高效并且可扩展的方式来定义和执行规则，帮助开发人员轻松地将规则集成到应用程序中。
一、Drools规则引擎框架概述Drools规则引擎框架是一个强大的规则引擎，它具有以下几个主要特点：1.声明式规则：Drools允许开发人员以声明式的方式定义业务规则，而无需编写复杂的代码。
这使得规则的维护和修改变得更加容易和灵活。
2.基于规则引擎的决策：Drools的核心功能是基于规则引擎进行决策。
规则引擎可以根据预定义的规则集对输入数据进行评估和处理，并生成相应的输出结果。
3.灵活性和可扩展性：Drools规则引擎框架提供了丰富的规则语法和API，使得开发人员能够根据自己的需求定义自定义规则，满足不同的业务场景。
4.规则验证和调试：Drools提供了强大的验证和调试工具，开发人员可以验证规则是否正确，并对规则执行的过程进行调试，以便快速发现和修复潜在的问题。
二、Drools规则引擎框架的主要模块Drools规则引擎框架由多个主要模块组成，每个模块都有不同的功能和用途。
1.核心引擎（Core Engine）：核心引擎是Drools规则引擎的核心组件，它负责解析规则，执行规则，以及生成结果。
核心引擎提供了完整的规则解析和执行的功能，确保规则的高效执行和准确性。
2.规则语言（Rule Language）：规则语言是Drools用于定义业务规则的语言。
Drools支持多种规则语言，如DRL（Drools Rule Language）和Decision Table，开发人员可以根据自己的需求选择适合的规则语言来定义规则。
3.事件处理（Event Processing）：Drools规则引擎框架支持事件处理，可以根据事件的发生和处理流程来触发和执行相应的规则。
事件处理模块提供了用于定义和管理事件的API和工具，使得规则引擎可以更好地适应动态的业务需求。
drools规则 判断空列表
Drools规则是一种基于Java的业务规则管理系统，它允许用户以自然语言的方式编写规则，以便在应用程序中进行实时的业务逻辑处理。
在使用Drools规则引擎时，经常会遇到对空列表进行判断的情况。
本文将从以下几个方面探讨在Drools规则中判断空列表的方法和注意事项。
一、Drools规则引擎简介Drools是一个基于规则的业务逻辑管理系统，它包括了一个核心规则引擎，以及一套用于构建业务规则的DSL（领域专用语言）和GUI （图形用户界面）工具。
Drools规则引擎的主要功能包括规则执行、规则管理、事实与规则匹配、规则触发等。
通过Drools规则引擎，用户可以将业务规则抽象成规则文件，然后在应用程序中动态加载并实时执行这些规则，以实现业务逻辑的灵活控制。
二、Drools规则中对空列表的判断在实际的业务场景中，经常会涉及到对列表数据进行判断和处理。
判断一个列表是否为空是一个常见的业务逻辑需求。
在Drools规则引擎中，对空列表的判断可以通过以下几种方式实现：1. 使用exists条件Drools规则文件中可以使用exists条件来判断某个列表是否为空。
exists条件表示存在某种条件的情况，可以用于判断列表是否为空。
例如：rule "Check If List Empty"when$list : List()exists(Object() from $list)then// 列表不为空的处理逻辑end```上面的规则文件中，当存在一个元素从$list列表中匹配时，就会触发该规则。
2. 使用empty方法Drools提供了empty方法来判断列表是否为空。
通过在规则文件中调用empty方法，可以方便地判断列表的空状态。
例如：```rule "Check If List Empty"when$list : List()eval(!$list.isEmpty())then// 列表不为空的处理逻辑end上面的规则文件中，通过调用isEmpty方法判断$list列表是否为空，如果不为空则触发该规则。
drools规则动态化实践
drools规则动态化实践一、前言Drools是一个基于规则引擎的开源项目，它提供了一种声明式的方式来表达业务规则，并通过推理引擎来执行这些规则。
Drools的规则动态化实践是指在运行时动态地修改或添加规则，从而实现业务逻辑的灵活性和可配置性。
二、Drools规则引擎简介1. 规则引擎基本概念规则引擎是指一个软件系统，能够根据预定义的条件和操作，自动执行相关的业务逻辑。
它通常由三个部分组成：规则库、推理引擎和应用程序接口。
2. Drools规则引擎特点Drools是一款基于Java语言开发的开源规则引擎。
它具有以下特点：（1）声明式表达：使用DSL（Domain Specific Language）语言来表达业务逻辑。
（2）可扩展性：支持插件机制，可以扩展自己所需的功能。
（3）可定制性：支持自定义推理策略和决策表。
（4）高效性：采用Rete算法进行推理处理，具有高效性能。
三、Drools规则动态化实践1. 动态加载规则文件在Drools中，可以使用KieFileSystem类来动态加载规则文件。
KieFileSystem类可以在运行时动态地加载、修改和删除规则文件。
下面是一个示例代码：KieServices ks = KieServices.Factory.get();KieFileSystem kfs = ks.newKieFileSystem();Resource resource =ks.getResources().newClassPathResource("rules.drl");kfs.write(resource);KieBuilder kbuilder = ks.newKieBuilder(kfs).buildAll(); KieContainer kcontainer =ks.newKieContainer(kbuilder.getKieModule().getReleaseId()); KieSession ksession = kcontainer.newKieSession();2. 动态修改规则在Drools中，可以使用KnowledgeBase类来动态修改规则。
drools规则引擎
Drools引擎一、drools是什么Drools是为Java量身定制的基于RETE算法的规则引擎的实现。
具有了OO（面向对象）接口的RETE,使得商业规则有了更自然的表达。
Rule是什么呢？一条规则是对商业知识的编码。
一条规则有 attributes ，一个 Left Hand Side （ LHS ）和一个 Right Hand Side （ RHS ）。
Drools 允许下列几种：attributes：salience，agenda-group，no-loop，auto-focus，duration，activation-group。
1.salience功能：设置规制执行的优先级值：数字(数字越大执行优先级越高)示例:rule "rule1"salience 1wheneval(true)thenSystem.out.println("rule1");end2.no-loop功能：控制已经执行的规则条件再次满足是否再次执行值:true/false示例:rule "rule1"no-loop truewhen$customer:Customer(name=="张三")thenupdate($customer);System.out.println("customer name:"+$customer.getName());End3.activation-group功能：若干个规则划分成一个组值：分组名称示例:rule "rule2"activation-group "test"salience 10wheneval(true)thenSystem.out.println("rule2 execute");endrule "rule1"activation-group "test"salience 9wheneval(true)thenSystem.out.println("rule1 execute");endnote:如果同一组规则，谁的salience高就执行谁，没有则按顺序执行最后同组最后那个规则4.date-expires功能：当系统时间<=date-expires后才会触发值:日期默认格式为dd-MMM-yyyy可以设置其它时间格式如yyyy-MM-dd,需在代码设置系统时间格式System.setProperty("drools.dateformat", "yyyy-MM-dd");示例:rule "rule1"date-expires "2009-09-27"wheneval(true);thenSystem.out.println("rule1 is execution!");end5、duration：规则定时，duration 3000 3秒后执行规则6、agenda-group：规则的调用与执行是通过Stateless KieSession或KieSession来实现的，一般的顺序是创建一个Stateless KieSession或KieSession，将各种经过编译的规则添加到session当中，然后将规则当中可能用到的Global对象和Fact对象插入到Session当中，最后调用fireAll Rules 方法来触发、执行规则。
Drools规则引擎介绍
8
© Copyright BSTEK Corporation 2006
TEAM BSTEK
Drools实现信用卡申请规则
▪ 采用Drools规则引擎来计算复杂的信用卡审批与发放规则 ▪ 通过Drools提供的BRMS——Guvnor实现规则的管理与动态更新 ▪ 通过Drools提供的RuleFlow(规则流)实现对信用卡审批规则的编排与执行
客
业务逻辑组件
户
调用
端
业务规则
客
业务
户
调用
逻辑
调用
端
组件
规则引擎
业务规则
引入规则引擎之前 引入规则引擎之后
▪ 引入规则引擎后带来的好处：
- 实现业务逻辑与业务规则的分离，实现业务规则的集中管理 - 可以动态修改业务规则，从而快速响应需求变更 - 使业务分析人员也可以参与编辑、维护系统的业务规则 - 使用规则引擎提供的规则编辑工具，使复杂的业务规则实现变得的简单
▪ /** ▪ 月收入在20000以上，那么发放的信用卡信用额度为15000。 ▪ */ ▪ rule "规则2" ▪ salience 2 ▪ ruleflow-group "creditcardpayment" ▪ lock-on-active true ▪ when ▪ Current user ▪ -salary is greate then 20000 ▪ then ▪ Payment credit card and credit limit is 15000 ▪ End
▪ ……
12
▪ 点击查看信用发放规则完整源文件
© Copyright BSTEK Corporation 2006
Drools 规则引擎
Drools规则引擎1. 概述:Drools分为两个主要部分：构建（Authoring）和运行时（Runtime）。
构建的过程涉及到.drl或.xml规则文件的创建，它们被读入一个解析器，使用ANTLR 3 语法进行解析。
解析器对语法进行正确性的检查，然后产生一种中间结构“descr”，descr 用AST来描述规则。
AST然后被传到PackageBuilder，由PackagBuilder来产生Packaged对象。
PackageBuilder还承担着一些代码产生和编译的工作，这些对于产生Package对象都时必需的。
Package对象是一个可以配置的，可序列化的，由一个或多个规则组成的对象。
下图阐明了上述过程：Figure 1.1 Authoring ComponentsRuleBase 是一个运行时组件，它包含了一个或多个 Package 对象。
可以在任何时刻将一个 Package 对象加入或移出 RuleBase 对象。
一个 RuleBase 对象可以在任意时刻实例化一个或多个 WorkingMemory 对象，在它的内部保持对这些WorkingMemory 的弱引用。
WorkingMemory 由一系列子组件组成。
当应用程序中的对象被 assert 进 WorkingMemory ，可能会导致一个或多个 Activation 的产生，然后由 Agenda 负责安排这些 Activation 的执行。
下图说明了上述过程：Figure 1.2 . Runtime Components2．构建（Authoring）：主要有三个类用来完成构建过程：DrlParser, XmlParser 和 PackageBuilder。
两个解析器类从传入的Reader实例产生descr AST模型。
PackageBuilder提供了简便的API，使你可以忽略那两个类的存在。
这两个简单的方法是：“addPackageFromDrl”和“addPackageFromXml”，两个都只要传入一个Reader 实例作为参数。
drools 可视化编排规则
drools 可视化编排规则一、什么是drools规则引擎drools规则引擎是一个基于规则的系统，它允许开发人员通过编写规则来描述业务逻辑。
规则由条件和动作组成，当条件满足时，对应的动作将被执行。
规则引擎可以将业务规则从应用程序中分离出来，使得规则可以独立于应用程序进行修改和管理。
这样一来，当业务规则发生变化时，不需要修改应用程序的源代码，只需要修改规则即可。
二、为什么需要可视化编排规则传统的规则编写方式通常是通过编写规则文件或代码来描述规则，这种方式对于非技术人员来说比较困难，容易出错。
而可视化编排规则可以提供一个直观、易于理解的界面，使非技术人员也能够参与规则的编写和管理工作。
此外，可视化编排规则还可以帮助开发人员更好地理解和管理复杂的规则逻辑，提高开发效率和可维护性。
三、drools规则引擎的可视化编排工具drools规则引擎提供了一个可视化编排工具，名为Drools Workbench。
Drools Workbench是基于Web的应用程序，可以通过浏览器访问。
它提供了一个图形化界面，可以帮助用户创建、编辑和管理规则。
通过Drools Workbench，用户可以创建规则集、定义规则条件和动作，并通过拖拽和连接的方式组织规则之间的关四、如何使用Drools Workbench进行可视化编排规则1. 创建规则集：在Drools Workbench中，用户可以创建一个规则集，用于组织规则。
规则集可以包含多个规则，用户可以根据业务逻辑的复杂度进行规则的组织和管理。
2. 定义规则条件和动作：在规则集中，用户可以创建规则，并定义规则的条件和动作。
条件是规则执行的前提，当条件满足时，对应的动作将被执行。
条件和动作的定义可以使用Drools提供的DSL 语言或者规则语言。
3. 可视化编排规则：在Drools Workbench中，用户可以使用拖拽和连接的方式来编排规则之间的关系。
用户可以将规则之间的依赖关系用箭头连接起来，以表示规则的执行顺序和条件。
drools规则动态化实践
drools规则动态化实践随着业务的不断发展和变化，传统的编程方式已经无法满足业务的需求。
因此，规则引擎的出现成为了解决这一问题的有效手段。
Drools作为一款开源的规则引擎，具有高效、灵活、易用等特点，被广泛应用于各个领域。
本文将介绍如何使用Drools规则动态化实践，以满足业务的快速变化和需求的动态调整。
一、Drools规则引擎简介Drools是一款基于Java的规则引擎，它可以将业务规则与应用程序分离，使得业务规则可以在不影响应用程序的情况下进行修改和调整。
Drools规则引擎的核心是规则引擎引擎，它可以将规则文件解析成规则对象，然后根据规则对象对数据进行匹配和处理。
Drools规则引擎的优点在于它可以实现业务规则的动态调整，从而满足业务的快速变化和需求的动态调整。
二、Drools规则动态化实践1.规则文件的动态加载Drools规则引擎支持将规则文件动态加载到规则引擎中，从而实现规则的动态调整。
在实际应用中，我们可以将规则文件存储在数据库或者文件系统中，然后通过程序动态加载规则文件。
下面是一个简单的示例代码：```//创建KieServices实例KieServices kieServices = KieServices.Factory.get();//创建KieFileSystem实例KieFileSystem kfs = kieServices.newKieFileSystem();//加载规则文件kfs.write(ResourceFactory.newClassPathResource("rules.drl"));//创建KieBuilder实例KieBuilder kieBuilder = kieServices.newKieBuilder(kfs).buildAll();//创建KieContainer实例KieContainer kieContainer = kieServices.newKieContainer(kieServices.getRepository().getD efaultReleaseId());//获取KieSession实例KieSession kieSession = kieContainer.newKieSession();```在上面的代码中，我们首先创建了KieServices实例，然后创建了KieFileSystem实例，并通过kfs.write()方法加载了规则文件。
drools 等级升级规则
drools 等级升级规则Drools等级升级规则引言：Drools是一种基于Java的规则引擎，可以用于规则的管理和执行。
规则引擎的作用是根据事实和规则，自动推断出结论。
在实际应用中，随着业务的发展和需求的变化，我们可能需要对规则进行升级。
本文将探讨Drools等级升级规则的方法和步骤。
一、规则引擎简介规则引擎是一种用于处理规则的软件工具，它将规则和数据分离，使得规则的修改和管理更加灵活和方便。
Drools是一种开源的规则引擎，它采用基于规则的编程模型，可以方便地定义和管理规则。
在使用Drools时，我们可以将规则和数据存储在规则库中，然后通过规则引擎来执行规则，根据事实和规则的匹配结果推断出结论。
二、规则的等级在实际应用中，规则往往需要根据业务需求进行调整和优化。
规则的等级可以用来表示规则的重要程度和执行顺序。
在Drools中，规则的等级通常通过设置规则的salience属性来实现。
salience属性是一个整数值，数值越高表示规则的等级越高，执行顺序越靠前。
通过设置规则的salience属性，我们可以控制规则的执行顺序，确保重要的规则优先执行。
三、规则的升级当业务需求发生变化时，我们可能需要对规则进行升级。
规则的升级可以包括以下几个方面：1. 新增规则：当需要添加新的业务规则时，我们可以通过在规则库中新增规则来实现。
新增规则时，需要注意规则的等级，确保新规则的执行顺序符合需求。
2. 修改规则：当已有规则需要进行修改时，我们可以通过修改规则的条件、动作或salience属性来实现。
修改规则时，需要仔细考虑规则的逻辑和影响范围，确保修改后的规则能够正确执行。
3. 删除规则：当某个规则不再适用或不需要执行时，我们可以通过删除规则来实现。
删除规则时，需要注意是否有其他规则依赖该规则，以避免影响其他规则的执行。
四、规则升级的步骤规则的升级通常需要经过以下几个步骤：1. 分析需求：首先，我们需要明确业务需求和规则的变更点，确定规则升级的目标和方向。
drools 动态加载规则
drools 动态加载规则Drools动态加载规则Drools是一个基于Java的开源规则引擎，它提供了一种灵活且高效的方法来处理复杂的业务规则。
通过Drools，我们可以将业务规则从应用程序中分离出来，实现规则的动态加载和修改，从而提高系统的可维护性和灵活性。
本文将介绍Drools动态加载规则的原理和应用场景，并探讨其在实际项目中的应用。
一、Drools规则引擎简介Drools是一个基于规则的系统，它使用规则来描述和控制业务逻辑。
规则由条件和动作组成，当条件满足时，动作被触发执行。
Drools 提供了一套丰富的语法和API，使得规则的编写和管理变得简单而灵活。
二、Drools动态加载规则的原理Drools的动态加载规则是通过规则文件的热加载实现的。
规则文件是以DRL（Drools Rule Language）的格式编写的，它包含了规则的条件和动作。
在应用程序启动时，Drools会将规则文件编译成可执行的规则，然后加载到规则引擎中。
当规则文件发生变化时，Drools会重新编译规则并重新加载到规则引擎中，实现规则的动态加载和修改。
三、Drools动态加载规则的应用场景1. 业务规则的动态配置：在一些业务系统中，业务规则可能会发生频繁的变化，通过Drools可以将规则配置在外部文件中，实现业务规则的动态加载和修改，而不需要重新编译和部署应用程序。
2. 规则的版本管理：通过Drools，可以将不同版本的规则保存在规则库中，并动态加载指定版本的规则，从而实现规则的版本管理和回滚。
3. 规则的动态学习：在一些机器学习领域，规则可以通过训练算法自动生成，Drools可以实现规则的动态加载和学习，从而提高系统的自动化程度和智能化水平。
四、Drools动态加载规则的实现步骤1. 编写规则文件：首先，我们需要编写规则文件，规则文件以.DRL 为后缀，使用Drools的规则语法来描述规则的条件和动作。
2. 加载规则文件：在应用程序启动时，我们需要将规则文件加载到Drools的规则引擎中。
drools 加载文本规则 -回复
drools 加载文本规则-回复需要注意的是，Drools 是一个规则引擎，用于执行业务规则，而不是加载文本规则。
在Drools中，我们需要将规则编写成一种特定的语法，然后将其编译为可执行的规则。
因此，本文将重点介绍Drools规则引擎的基本概念和使用方法。
第一步：介绍Drools规则引擎的基本概念Drools是一种基于规则的业务流程管理系统，它采用了基于Java的规则引擎，用于执行和管理业务规则。
Drools的基本概念包括规则库、事实和规则。
规则库是指存储和管理各种规则的集合，每个规则由左部和右部组成。
左部描述了规则的条件（也称为触发器），右部描述了满足条件时需要执行的操作。
事实是规则的输入数据，它们被用来验证规则的条件是否满足。
规则引擎会根据规则库的定义和事实的输入来自动触发和执行规则。
第二步：了解Drools的规则语法和语义在Drools中，规则的编写是基于DRL（Drools Rule Language）的规则语法和语义。
DRL是一种基于文本的规则描述语言，它使用一系列关键字和语法结构来定义规则的条件和动作。
常见的关键字包括“when”用于定义规则的条件部分，“then”用于定义规则的动作部分，“rule”用于定义规则的名称和属性等。
此外，DRL还提供了一些内置函数和操作符来实现复杂的规则逻辑和计算。
第三步：编写DRL规则文件DRL规则文件是存储和管理规则的基本单元，在Drools中可以通过加载DRL文件来加载规则。
要编写DRL规则文件，首先需要定义规则的名称和属性，然后编写规则的条件和动作。
规则的条件部分通常由“when”关键字开始，后面跟随一系列的模式和限制条件。
模式用于描述规则应用的对象和属性，限制条件则用于约束规则的匹配范围。
规则的动作部分通常由“then”关键字开始，后面跟随一系列的操作和函数调用。
第四步：编译和加载规则在Drools中，要执行规则，需要先将规则编译为可执行的规则。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
系统架构
Client 端
Dorado表现层接收用户输入信用卡申请信息
控件
绑定
Server端
业务逻辑层 Drools的BRMS-Guvnor
Dataset
业务逻辑
信用卡审批规则流
Drools规则引擎
信用卡审批规则
用户
9
Drools实现的信用卡自动审批流程
• “检查申请人信息是否合法”：用来存放 检查申请人信息是否合法的四条规则，对 申请人信息进行合法性检查。
传统业务逻辑编写方式 引入规则引擎后业务 逻辑组件的编写方式
客 户 端
包含业务规则的 业务逻辑组件
调用
业务规则
客 户 端
调用
业务 逻辑 组件
规则引擎
调用
业务规则
引入规则引擎之前
引入规则引擎之后
引入规则引擎后带来的好处：
-
实现业务逻辑与业务规则的分离，实现业务规则的集中管理 可以动态修改业务规则，从而快速响应需求变更 使业务分析人员也可以参与编辑、维护系统的业务规则 使用规则引擎提供的规则编辑工具，使复杂的业务规则实现变得的简单
3
Drools规则引擎介绍
• Drools是Jboss公司旗下一款开源的规则引擎，它完整的实现了Rete
算法；提供了强大的Eclipse Plugin开发支持； 通过使用其中的DSL(Domain Specific Language)，可以实现用自然语言方式来描述业务规则，使得业务分析人 员也可以看懂业务规则代码。 • 最新版本Drools5提供了基于WEB的BRMS——Guvnor，Guvnor提供了规则管理的知识库，通过它可以实现 规则的版本控制，及规则的在线修改与编译，使得开发人员和系统管理人员可以在线管理业务规则。
•
利用Drools提供的Rule Flow设计的信用卡 审批流程，该流程的主要作用是用来对信用 卡的合法性检查规则及信用卡发放规则的执 行顺序进行编排。
存放检查申请人信息是 否合法的四条规则
•
•
10
Drools实现的用户信息合法性检查规则
/** 如果申请人既没房也没车，同时学历为大专及以下，并且月薪少于5000，那么不通过。 */ rule "检查学历与薪水1" ruleflow-group "applycheck" lock-on-active true salience 1 when Current user -degree is 1 -has car is false -has house is false -salary is less then 5000 then So current user apply is invalid end /** 如果申请人既没房也没车，同时学历为大专或本科，并且月薪少于3000，那么不通过。 */ rule "检查学历与薪水2" ruleflow-group "applycheck" lock-on-active true salience 2 when Current user -has car is false -has house is false -salary is less then 3000 -current user degree is 2 or 3 then So current user apply is invalid End
以上5条规则为验证通过的用户发放信用卡时使用，主要是用来决定信用卡 的发放额度
8
Drools实现信用卡申请规则
• • • 采用Drools规则引擎来计算复杂的信用卡审批与发放规则 通过Drools提供的BRMS——Guvnor实现规则的管理与动态更新 通过Drools提供的RuleFlow(规则流)实现对信用卡审批规则的编排与执行
“判断是否合法”：判断当前申请人信息 是否合法，如果合法那么将选择“合法” 线路，否则选择“非法”线路。 “合法申请人信用卡发放”：存放发放信 用卡的五条规则，对申请人的信息进行检 查，从而为申请人提供合适的信用卡额度。 两个结束节点分别用来结束合法与非法的 信用卡申请信息。
判断当前申请人申请信息是 否合法来决定要走的线路 存放发放信用卡的 五条规则
Dorado客户端
提供信用卡申请信息
Drools规则引擎
信用卡申请规则
Dorado客户端调用规则引擎进行信用卡申请
14
返回申请结果
谢谢
……
11
•
点击查看用户信息合法性检查规则的完整源文 件
Drools实现的合法用户的信用卡发放规则
• • • • • • • • • • • • • • • • • • • • • • • • • • • /** 如果申请人有房有车，那么发放的信用卡信用额度为15000。 */ rule "规则1" salience 1 ruleflow-group "creditcardpayment" lock-on-active true when Current user -has car is true -has house is true then Payment credit card and credit limit is 15000 end /** 月收入在20000以上，那么发放的信用卡信用额度为15000。 */ rule "规则2" salience 2 ruleflow-group "creditcardpayment" lock-on-active true when Current user -salary is greate then 20000 then Payment credit card and credit limit is 15000 End
13
编写客户端测试信用卡申请规则
•
•
为了可以更加真实的反映Drools的使用方法，我们用一个B/S架构的应用来作为规则调用 的客户端。 Drools的客户端采用Dorado实现，通过Dorado客户端提供申请人申请信息，再这些信息交 给Drools进行合法性检查，对于合法的申请再进行信用卡的发放，最将结果返回给Dorado。
4
薪少于2000，同时之前没有信用卡的，那么不通过。
检查申请人已有 如果申请人现有的信用卡数量大于10，那么不通过。 的信用卡数量
申请人信息提交到系统后，首先调用这些规则进行验证，只有这些规 则全部通过，才能进入发放信用卡的流程，否则申请结果就是不通过。
7
合法用户的信用卡发放规则
规则编号
1 2 3 4 5
Drools规则引擎
议程
• • • • • 什么是规则引擎？ Drools规则引擎介绍 信用卡申请实例介绍 Drools实现信用卡申请规则 编写客户端测试信用卡申请规则
2
什么是规则引擎？
• 规则引擎是一种嵌套在应用程序中的组件，它实现了将业务规则从应用程序代码中分离出 来。规则引擎使用特定的语法编写业务规则，规则引擎可以接受数据输入、解释业务规则、 并根据业务规则做出相应的决策。
名称
规则1 规则2 规则3 规则4 规则5 用卡信用额度为15000。
描述
如果申请人有房有车Байду номын сангаас或者月收入在20000以上，那么发放的信 如果申请人没房没车，但月收入在10000~20000之间，那么发
放的信用卡信用额度为6000
如果申请人没房没车，月收入在10000以下，那么发放的信用额 度为3000。 如果申请人有房没车或者是没房但有车，月收入在10000以下， 那么发放的信用额度为5000。 如果申请人有房没车或者是没房但有车，月收入在10000~2000 之间，那么发放的信用额度为8000。
规则编号 1 名称 检查学历 描述 如果申请人既没房也没车，同时学历为大专及以下，并且
与薪水1
2 检查学历 与薪水2 3 检查学历
月薪少于5000，那么不通过。
如果申请人既没房也没车，同时学历为大专或本科，并且 月薪少于3000，那么不通过。 如果申请人既没房也没车，同时学历为本科以上，并且月
与薪水3
5
用户需要输入的个人信息
• 用户需要输入的信息包括：姓名、性别、年龄、学历、电话、所在公司、职位、月收入、 是否有房、是否有车、是否有信用卡等。
点击“申请”按钮将申请信息提交到后台，后台启动审批流程，通过规则先对信息的合法性进 行验证，对于验证合格申请系统将调用相关规则发放相关的信用卡。
6
用户信息合法性检查规则
Eclipse Plugin版规则设计器
Drools的Guvnor
4
信用卡申请实例
申请流程图
信息提交
信息录入
通知申请人 申请结果
使用规则进行 合法性检查
通过规则 发放信用卡
1. 用户填写申请的个人信息。
2. 然后提交到系统进行初审。初审的职责是通过已有的规则对用户信息合法性和真实性进行检 查。 3. 对于合法的用户提交到信用卡发放部门，使用规则来决定要发放的信用卡额度等信息。 4. 通知申请人申请结果
•
……
点击查看信用发放规则完整源文件
12
将相关规则文件部署到Guvnor
申请人信息合法性检查规则在Guvnor里查看的效果 在Guvnor里查看信用卡审批的规则流程图
可以将编写好的信用卡申请规则及编排规则执行的规则流文件一起发布到Guvnor，通过 Guvnor可以实现对规则的管理与动态编译，以快速的响应业务变化需求。 通过使用Guvnor提供的Eclipse-plugin可以将规则文件直接部署到Guvnor当中。