JAVA规则引擎 -- Drools
drools的使用

Drools的使用什么是DroolsDrools是一个基于Java的规则引擎,它能够帮助开发者以一种简单、易于理解的方式来管理和执行业务规则。
它提供了一个强大的规则引擎,允许用户定义和管理业务规则,并将这些规则应用到应用程序中的数据上。
Drools的核心是一个基于规则的语言,即Drools Rule Language(DRL)。
通过使用DRL,开发者可以定义规则、条件和操作,以及规则之间的关系。
Drools引擎可以解析和执行这些规则,并根据规则的评估结果进行相应的操作。
Drools的优势Drools具有以下几个优势:1. 灵活性Drools允许开发者以一种灵活的方式定义规则,并根据实际需求进行修改和调整。
规则可以通过简单的文本编辑器进行编写,也可以通过使用Drools提供的规则编辑器进行可视化编辑。
这使得开发者能够快速响应业务需求的变化,并进行规则的动态更新。
2. 可读性和可维护性Drools的规则语言(DRL)采用了一种易于理解的语法,使得规则的编写和维护变得简单。
规则可以根据业务需求进行组织和分组,使得规则的管理和维护更加清晰和可靠。
此外,Drools还提供了一些工具和插件,可以帮助开发者进行规则的调试和测试,进一步提高规则的可读性和可维护性。
3. 高性能Drools引擎是一个高性能的规则引擎,它能够处理大量的规则和数据,并在短时间内完成规则的评估和操作。
Drools引擎采用了一些优化策略,如规则的编译和缓存,以提高规则的执行效率。
此外,Drools还支持多线程和分布式处理,可以进一步提高规则引擎的性能和扩展性。
4. 与Java的无缝集成Drools是一个基于Java的规则引擎,它可以与Java应用程序无缝集成。
开发者可以使用Java代码调用Drools引擎,并将规则应用到Java对象上。
Drools提供了一些API和工具,可以帮助开发者在Java应用程序中使用规则引擎,使得规则的集成变得简单和方便。
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 规则重复执行

drools 规则重复执行Drools是一个基于Java的开源规则引擎,它可以在应用程序中执行规则,根据给定的条件和动作进行推理和决策。
Drools规则引擎的重复执行是指规则引擎在特定条件下重复执行规则的过程。
本文将探讨Drools规则引擎的重复执行机制以及其在实际应用中的一些使用场景。
让我们了解Drools规则引擎的基本原理。
Drools规则引擎基于规则的条件和动作进行推理和决策。
规则由两部分组成:条件和动作。
条件是指规则引擎需要满足的前提条件,而动作是在条件满足时需要执行的操作。
当给定的条件满足时,规则引擎会执行相应的动作。
Drools规则引擎的重复执行是指规则引擎在满足条件的情况下,可以多次执行规则。
这是通过规则引擎的循环执行机制实现的。
当规则引擎执行完一次规则后,它会重新评估条件,并根据条件的变化情况决定是否需要再次执行规则。
如果条件仍然满足,规则引擎将继续执行规则,直到条件不再满足为止。
Drools规则引擎的重复执行机制可以在很多实际应用中发挥作用。
例如,在订单处理系统中,可以使用Drools规则引擎来执行一系列的订单验证规则。
当新的订单被创建时,规则引擎可以根据一组预定义的规则来验证订单的合法性。
如果订单不符合规则的条件,规则引擎可以执行相应的动作,如发送警报或拒绝订单。
在订单处理过程中,规则引擎可以重复执行规则,以确保订单的合法性。
另一个使用Drools规则引擎的场景是风险管理系统。
在金融领域,风险管理是非常关键的一项任务。
Drools规则引擎可以用于执行一系列的风险评估规则。
当新的交易发生时,规则引擎可以根据一组预定义的规则来评估交易的风险。
如果交易的风险超过了设定的阈值,规则引擎可以执行相应的动作,如发送警报或拒绝交易。
在风险管理过程中,规则引擎可以重复执行规则,以及时发现和应对风险。
除了以上应用场景,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的项⽬等:。
Java规则引擎——Drools的介绍及应用

第26卷第6期2005年11月微计算机应用M ICROCO M PU IER AP PL ICAT ION S Vo l.26No.6No v.2005本文于2004-12-13收到。
Java 规则引擎)))Drools 的介绍及应用刘 伟(中国科技大学 合肥 230026)摘 要:规则引擎技术是一项很有吸引力的技术。
首先介绍了规则引擎的相关概念及其实现原理。
然后重点介绍了Jav a 规则引擎技术的规范和一个采用XM L 和jav a 语言实现的规则引擎)))Dr oo ls 。
最后给出了利用Dr oo ls 解决实际问题的范例并探讨了该技术的不足和发展前景。
关键词:规则引擎,JSR 94,DroolsIntroduction and Implementation of Drools )))a Rule Engine Based JavaLIU W ei(Univ of Sci &T ech of China,H efei,230026,China)Abstract:Rule Eng ine is a mag net ic technolog y in the ar ea o f so ftwar e developing now.In this paper,firstly,the co ncept and im plementing pr inciple of Rule Engine is int roduced,and then JSR94,the Java pro gr aming specif icat ion of Rale Engine is presented.As a pro duct of Java Rule Engine,D roo ls,is emphasized smbsequently.pr oviding an actual example,the paper descr ibes the det ails o f the usage o f Dro ds finally.Keywords:Rule Eng ine,JSR94Dr ools1 基于规则的专家系统简介Jav a 规则引擎是推理引擎的一种,它起源于基于规则的专家系统。
Drools入门

Drools⼊门⼀、背景知识:1、什么是规则引擎Java规则引擎起源于基于规则的专家系统,⽽基于规则的专家系统⼜是专家系统的其中⼀个分⽀。
专家系统属于⼈⼯智能的范畴,它模仿⼈类的推理⽅式,使⽤试探性的⽅法进⾏推理,并使⽤⼈类能理解的术语解释和证明它的推理结论。
推理引擎包括三部分:模式匹配器(Pattern Matcher)、议程(Agenda)和执⾏引擎(Execution Engine)。
推理引擎通过决定哪些规则满⾜事实或⽬标,并授予规则优先级,满⾜事实或⽬标的规则被加⼊议程。
模式匹配器决定选择执⾏哪个规则,何时执⾏规则;议程管理模式匹配器挑选出来的规则的执⾏次序;执⾏引擎负责执⾏规则和其他动作。
和⼈类的思维相对应,推理引擎存在两者推理⽅式:演绎法(Forward-Chaining)和归纳法(Backward-Chaining)。
演绎法从⼀个初始的事实出发,不断地应⽤规则得出结论(或执⾏指定的动作)。
⽽归纳法则是根据假设,不断地寻找符合假设的事实。
Rete算法是⽬前效率最⾼的⼀个 Forward-Chaining推理算法,许多Java规则引擎都是基于Rete算法来进⾏推理计算的。
推理引擎的推理步骤如下:(1)将初始数据(fact)输⼊Working Memory。
(2)使⽤Pattern Matcher⽐较规则库(rule base)中的规则(rule)和数据(fact)。
(3)如果执⾏规则存在冲突(conflict),即同时激活了多个规则,将冲突的规则放⼊冲突集合。
(4)解决冲突,将激活的规则按顺序放⼊Agenda。
(5)使⽤执⾏引擎执⾏Agenda中的规则。
重复步骤2⾄5,直到执⾏完毕所有Agenda中的规则。
上述即是规则引擎的原始架构,Java规则引擎就是从这⼀原始架构演变⽽来的。
Drools是基于正向推理的规则引擎。
正向推理是数据驱动的,facts事实被传递到⼯作空间中,在那⾥有⼀个或多个规则与这些事实匹配,并由Agenda安排执⾏—我们从⼀个事实开始,传递事实,最后得到⼀个结论。
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规则引擎的一般步骤,具体实现方式可能会因项目需求和开发环境而有所不同。
Java规则引擎:Drools和JRules

Java规则引擎:Drools和JRules引言在软件开发中,处理业务逻辑和规则是非常重要的一部分。
传统的方法是将这些规则硬编码到应用程序中,这样一来,每当规则发生变化时,都需要修改和重新部署整个应用程序。
这种方式显然不够灵活和易于维护。
为了解决这个问题,出现了规则引擎。
规则引擎是一种能够将业务规则从应用程序中分离出来,以便在运行时动态加载和执行的软件组件。
Java语言中有许多优秀的规则引擎,其中两个最受欢迎的是Drools和JRules。
本文将介绍这两个规则引擎的特点、优势和用法。
一、Drools1.1 特点Drools是一个基于Java的开源规则引擎,由Jboss社区开发和维护。
它提供了一种声明式的规则语言,称为DRL(Drools Rule Language),以及一个规则引擎,用于加载和执行这些规则。
Drools支持复杂的规则和事件处理,能够处理大规模的数据和规则集。
1.2 优势Drools具有许多优势,使其成为开发人员首选的规则引擎。
首先,Drools具有强大的规则语言和表达能力。
DRL语言使用自然语言的方式描述规则,易于理解和维护。
它支持多种规则类型,如条件规则、动作规则和查询规则,可以轻松处理复杂的业务逻辑。
其次,Drools具有灵活的规则引擎和推理机制。
它能够处理不同类型的规则,如前向链式规则、后向链式规则和决策表规则。
它还支持基于事件的规则和实时规则,可以根据不同的需求选择合适的规则执行方式。
最后,Drools提供了丰富的工具和插件,使规则的开发和管理更加简单和高效。
它提供了一个图形化的规则编辑器,可以帮助开发人员可视化地创建和编辑规则。
此外,Drools还支持与其他技术的集成,如Spring框架和RESTful服务,使其更易于集成到现有的应用程序中。
1.3 用法Drools的使用非常简单和灵活。
首先,我们需要定义规则,可以使用DRL语言编写规则文件,也可以使用图形化的规则编辑器创建规则。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Drools是一个基于java的规则引擎,开源的,可以将复杂多变的规则从硬编码中解放出来,以规则脚本的形式存放在文件中,使得规则的变更不需要修正代码重启机器就可以立即在线上环境生效。
1、Drools语法开始语法之前首先要了解一下drools的基本工作过程,通常而言我们使用一个接口来做事情,首先要穿进去参数,其次要获取到接口的实现执行完毕后的结果,而drools也是一样的,我们需要传递进去数据,用于规则的检查,调用外部接口,同时还可能需要获取到规则执行完毕后得到的结果。
在drools 中,这个传递数据进去的对象,术语叫Fact对象。
Fact 对象是一个普通的java bean,规则中可以对当前的对象进行任何的读写操作,调用该对象提供的方法,当一个java bean插入到workingMemory中,规则使用的是原有对象的引用,规则通过对fact对象的读写,实现对应用数据的读写,对于其中的属性,需要提供getter setter访问器,规则中,可以动态的往当前workingMemory中插入删除新的fact对象。
规则文件可以使用 .drl文件,也可以是xml文件,这里我们使用drl文件。
规则语法:package:对一个规则文件而言,package是必须定义的,必须放在规则文件第一行。
特别的是,package的名字是随意的,不必必须对应物理路径,跟java 的package的概念不同,这里只是逻辑上的一种区分。
同样的package下定义的function和query等可以直接使用。
比如:package com.drools.demo.pointimport:导入规则文件需要使用到的外部变量,这里的使用方法跟java相同,但是不同于java的是,这里的import导入的不仅仅可以是一个类,也可以是这个类中的某一个可访问的静态方法。
比如:import com.drools.demo.point.PointDomain;import com.drools.demo.point.PointDomain.getById;rule:定义一个规则。
rule "ruleName"。
一个规则可以包含三个部分:属性部分:定义当前规则执行的一些属性等,比如是否可被重复执行、过期时间、生效时间等。
条件部分,即LHS,定义当前规则的条件,如 when Message(); 判断当前workingMemory中是否存在Message对象。
结果部分,即RHS,这里可以写普通java代码,即当前规则条件满足后执行的操作,可以直接调用Fact对象的方法来操作应用。
规则事例:rule "name"no-loop truewhen$message:Message(status == 0)thenSystem.out.println("fit");$message.setStatus(1);update($message);end上述的属性中:no-loop: 定义当前的规则是否不允许多次循环执行,默认是false,也就是当前的规则只要满足条件,可以无限次执行。
什么情况下会出现一条规则执行过一次又被多次重复执行呢?drools提供了一些api,可以对当前传入workingMemory中的Fact对象进行修改或者个数的增减,比如上述的update 方法,就是将当前的workingMemory中的Message类型的Fact对象进行属性更新,这种操作会触发规则的重新匹配执行,可以理解为 Fact对象更新了,所以规则需要重新匹配一遍,那么疑问是之前规则执行过并且修改过的那些Fact对象的属性的数据会不会被重置?结果是不会,已经修改过了就不会被重置,update 之后,之前的修改都会生效。
当然对Fact对象数据的修改并不是一定需要调用update才可以生效,简单的使用set方法设置就可以完成,这里类似于java 的引用调用,所以何时使用update是一个需要仔细考虑的问题,一旦不慎,极有可能会造成规则的死循环。
上述的 no-loop true,即设置当前的规则,只执行一次,如果本身的RHS部分有update等触发规则重新执行的操作,也不要再次执行当前规则。
但是其他的规则会被重新执行,岂不是也会有可能造成多次重复执行,数据紊乱甚至死循环?答案是使用其他的标签限制,也是可以控制的:lock-on-active truelock-on-active true:通过这个标签,可以控制当前的规则只会被执行一次,因为一个规则的重复执行不一定是本身触发的,也可能是其他规则触发的,所以这个是no-loop的加强版。
当然该标签正规的用法会有其他的标签的配合,后续提及。
date-expires:设置规则的过期时间,默认的时间格式:“日-月-年”,中英文格式相同,但是写法要用各自对应的语言,比如中文:"29-七月-2010",但是还是推荐使用更为精确和习惯的格式,这需要手动在java代码中设置当前系统的时间格式,后续提及。
属性用法举例:date-expires "2011-01-31 23:59:59" // 这里我们使用了更为习惯的时间格式date-effective:设置规则的生效时间,时间格式同上。
duration:规则定时,duration 3000 3秒后执行规则salience:优先级,数值越大越先执行,这个可以控制规则的执行顺序。
其他的属性可以参照相关的api文档查看具体用法,此处略。
规则的条件部分,即LHS部分:when:规则条件开始。
条件可以单个,也可以多个,多个条件一次排列,比如wheneval(true)$customer:Customer()$message:Message(status==0)上述罗列了三个条件,当前规则只有在这三个条件都匹配的时候才会执行RHS部分,三个条件中第一个eval(true):是一个默认的api,true 无条件执行,类似于 while(true)$message:Message(status==0)这句话标示的:当前的workingMemory存在Message类型并且status属性的值为0的Fact对象,这个对象通常是通过外部java代码插入或者自己在前面已经执行的规则的RHS部分中insert进去的。
前面的$message代表着当前条件的引用变量,在后续的条件部分和RHS部分中,可以使用当前的变量去引用符合条件的FACT对象,修改属性或者调用方法等。
可选,如果不需要使用,则可以不写。
条件可以有组合,比如:Message(status==0 || (status > 1 && status <=100))RHS中对Fact对象private属性的操作必须使用getter和setter方法,而RHS 中则必须要直接用.的方法去使用,比如$order:Order(name=="qu")$message:Message(status==0 && orders contains $order &&$=="qu")特别的是,如果条件全部是 &&关系,可以使用“,”来替代,但是两者不能混用如果现在Fact对象中有一个List,需要判断条件,如何判断呢?看一个例子:Message {int status;List<String> names;}$message:Message(status==0 && names contains "网易" && names.size >= 1)上述的条件中,status必须是0,并且names列表中含有“网易”并且列表长度大于等于1contains:对比是否包含操作,操作的被包含目标可以是一个复杂对象也可以是一个简单的值。
Drools提供了十二中类型比较操作符:> >= < <= == != contains / not contains / memberOf / not memberOf /matches/ not matchesnot contains:与contains相反。
memberOf:判断某个Fact属性值是否在某个集合中,与contains不同的是他被比较的对象是一个集合,而contains被比较的对象是单个值或者对象。
not memberOf:正好相反。
matches:正则表达式匹配,与java不同的是,不用考虑'/'的转义问题not matches:正好相反。
规则的结果部分当规则条件满足,则进入规则结果部分执行,结果部分可以是纯java代码,比如:thenSystem.out.println("OK"); //会在控制台打印出okend当然也可以调用Fact的方法,比如 $message.execute();操作数据库等等一切操作。
结果部分也有drools提供的方法:insert:往当前workingMemory中插入一个新的Fact对象,会触发规则的再次执行,除非使用no-loop限定;update:更新modify:修改,与update语法不同,结果都是更新操作retract:删除RHS部分除了调用Drools提供的api和Fact对象的方法,也可以调用规则文件中定义的方法,方法的定义使用 function 关键字function void console {System.out.println();StringUtils.getId();// 调用外部静态方法,StringUtils必须使用import 导入,getId()必须是静态方法}Drools还有一个可以定义类的关键字:declare可以再规则文件中定义一个class,使用起来跟普通java对象相似,你可以在RHS部分中new一个并且使用getter和setter方法去操作其属性。
declare Address@author(quzishen) // 元数据,仅用于描述信息@createTime(2011-1-24)city : String @maxLengh(100)postno : intend上述的'@'是什么呢?是元数据定义,用于描述数据的数据~,没什么执行含义你可以在RHS部分中使用Address address = new Address()的方法来定义一个对象。