Drools规则引擎开发说明

[Drools]JA V A规则引擎(非常好的一篇教程)Drools是一个基于java的规则引擎，开源的，可以将复杂多变的规则从硬编码中解放出来，以规则脚本的形式存放在文件中，使得规则的变更不需要修正代码重启机器就可以立即在线上环境生效。

本文所使用的demo已上传/source/30022131、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导入的不仅仅可以是一个类，也可以是这个类中的某一个可访问的静态方法。

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使⽤讲解（简单版）-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的项⽬等：。

magnum规则转drools规则概述及解释说明1. 引言1.1 概述：本篇文章主要介绍了将magnum规则转换为drools规则的过程和实际应用案例分析。

在软件开发中，规则引擎起着至关重要的作用，它可以帮助我们轻松管理和执行一系列复杂的业务规则。

Magnum和Drools都是流行的规则引擎，在不同领域有广泛应用。

然而，由于Magnum和Drools之间存在一些语法和结构上的差异，因此需要将Magnum规则转换为Drools规则。

1.2 文章结构：本文共分为五个部分进行叙述。

首先，在引言部分我们对文章的背景进行了概述，并说明了文章的结构。

接下来，我们将介绍Magnum规则与Drools规则的简介，包括它们各自的特点和应用场景。

然后，我们将详细说明Magnum规则转换为Drools规则的过程步骤，并通过示例进行说明。

在第四部分中，我们会提供一个实际应用案例进行分析，包括案例背景介绍、转换流程及方法解释以及结果与效果评估。

最后，我们将总结本文主要观点并展望未来发展方向。

1.3 目的：本文的目的是为读者提供一个全面而系统的指南，帮助他们了解Magnum规则转换为Drools规则的过程，并能够在实际应用中灵活运用。

同时，通过案例分析，读者还能够更好地理解这一转换过程对于业务规则管理和执行效果的影响。

我们希望本文能够为那些需要将现有Magnum规则转换为Drools规则的开发者、项目经理和决策者提供有价值的参考，并推动相关技术在未来的研究和发展中取得进一步突破。

2. Magnum规则与Drools规则简介:2.1 Magnum规则概述:Magnum是一种规则引擎，它提供了一种用于编写和执行业务规则的框架。

该框架允许用户将业务规则与应用程序分开，以实现更高的灵活性和可维护性。

Magnum使用基于文本的规则语言，通过定义条件和行动来描述业务规则。

2.2 Drools规则概述：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是一个基于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规则引擎初窥---drl和决策表实现[实例]因项⽬需要，看了下drools规则引擎。

写了⼀个⽐较简单的drools的drl规则和决策表实现的例⼦。

规则说明： ⽹络商城要举办活动（奖励额外积分）， 订单原价⾦额在 100以下, 不加分 100-500 加100分 500-1000 加500分 1000 以上加1000分1.建⽴最基本的Drools项⽬结构并引⼊必须的类库。

（这⾥采⽤junit来执⾏单元测试）。

创建⼀个Java Project，建⽴maven形式的源码包。

2.定义实体类Order.java1import java.util.Date;23public class Order {4private Date bookingDate;// 下单⽇期56private int amout;// 订单原价⾦额78private User user;// 下单⼈910private int score;//积分1112public Order(Date bookingDate,int amout, User user, int score){13this.bookingDate = bookingDate;14this.amout = amout;er = user;16this.score = score;17 }1819public Order(){20 }2122 //省略get、set⽅法5354 }3.定义实体User.javapublic class User {private String name;// 姓名private int level;// ⽤户级别public User(){}public User(String name, int level){ = name;this.level = level;}//省略get、set⽅法4.编写规则⽂件point-rules.drlpackage droolsimport com.wang.drools.point.Orderimport errule "zero"no-loop true//只检查⼀次lock-on-active truesalience 9 //值越⼤，优先级越⾼when//购物⾦额100以下不加分$s : Order(amout <= 100);then$s.setScore(0);update($s);endrule "add100"no-loop true//只检查⼀次lock-on-active truesalience 8 //值越⼤，优先级越⾼when//购物⾦额100以上500以下加100积分$s : Order(amout > 100 && amout <= 500);then$s.setScore(100);update($s);endrule "add500"no-loop true//只检查⼀次lock-on-active truesalience 6 //值越⼤，优先级越⾼when//购物⾦额500以上1000以下加500积分$s : Order(amout > 500 && amout <= 1000);then$s.setScore(500);update($s);endrule "add1000"no-loop true//只检查⼀次lock-on-active truesalience 5 //值越⼤，优先级越⾼when//购物⾦额1000以上加1000积分$s : Order(amout > 1000);then$s.setScore(1000);update($s);end说明：rule表⽰规则的开始，salience表⽰规则的优先级，当有多条规则同时存在是，优先级越⾼的越先被匹配执⾏。

Drools规则引擎⼊门指南（⼀）最近项⽬需要增加风控系统，在经过⼀番调研以后决定使⽤Drools规则引擎。

因为项⽬是基于SpringCloud的架构，所以此次学习使⽤了SpringBoot2.0版本结合Drools7.14.0.Final版本。

引⼊依赖1 2 3 4 5 6 7 8 9 10<dependency><groupId>org.drools</groupId><artifactId>drools-core</artifactId> <version>7.14.0.Final</version> </dependency><dependency><groupId>org.kie</groupId><artifactId>kie-spring</artifactId> <version>7.14.0.Final</version> </dependency>创建配置类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@Configurationpublic class DroolsAutoConfiguration {private static final String RULES_PATH = "rules/";@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(new KieModule() {public ReleaseId getReleaseId() {return kieRepository.getDefaultReleaseId();}});KieBuilder kieBuilder = getKieServices().newKieBuilder(kieFileSystem());kieBuilder.buildAll();return getKieServices().newKieContainer(kieRepository.getDefaultReleaseId());}@Bean@ConditionalOnMissingBean(KieBase.class)public KieBase kieBase() throws IOException {return kieContainer().getKieBase();}@Bean@ConditionalOnMissingBean(KieSession.class)public KieSession kieSession() throws IOException {KieSession kieSession = kieContainer().newKieSession();return kieSession;}@Bean@ConditionalOnMissingBean(KModuleBeanFactoryPostProcessor.class)public KModuleBeanFactoryPostProcessor kiePostProcessor() {return new KModuleBeanFactoryPostProcessor();}public KieServices getKieServices() {System.setProperty("drools.dateformat","yyyy-MM-dd");return KieServices.Factory.get();}}在这个时候我们的基本环境已经搭建好了，接下来我们⼀起来学习Drools吧HelloWord程序员的世界⾥，我们学习任何⼀门语⾔都是以HelloWord开启的，本次学习也不例外。

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来编写规则。

1. 规则文件（DRL文件）Drools的规则是使用规则文件（DRL文件）进行定义和管理的。

一个规则文件主要包含三个部分：包定义、导入声明和规则定义。

包定义用于指定规则文件所属的包名称，导入声明用于引入所需的外部类或接口，而规则定义则是实际编写业务规则的地方。

2. 规则定义规则定义是Drools规则文件中最重要的部分。

每个规则由以下几个元素组成：- 规则名称：用于标识规则的名称，应具备唯一性。

- 规则条件（也称为左手边，LHS）：规定了触发规则执行的条件，可以使用Drools提供的丰富条件语句来描述。

- 规则动作（也称为右手边，RHS）：规定了满足规则条件后要执行的操作，可以是业务逻辑、函数调用或修改事实等。

3. 规则条件规则条件是规定规则执行条件的部分，通过使用Drools提供的条件语句来描述。

常用的条件语句包括：- 关系运算符：如==、!=、>、<等。

- 逻辑运算符：如&&（与）、||（或）、!（非）等。

- 模式匹配：使用DSL语法或规则语法进行模式匹配，匹配事实和对象属性等。

4. 规则动作规则动作是满足规则条件后要执行的操作。

可以在规则动作中实现业务逻辑、进行事实修改、调用函数等。

常用的规则动作语句包括：- 插入动作：使用"insert"关键字将对象插入到工作内存中。

- 修改动作：使用"modify"关键字修改对象的属性值。

- 删除动作：使用"retract"关键字将对象从工作内存中移除。

5. 规则的优先级和salience属性规则可以通过设置优先级来影响其执行顺序。

优先级数值越高，表示优先级越高，默认情况下，规则的优先级为0。

一、简介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的基本用法，包括规则的创建、规则库的管理和规则的执行。

Drools的基本概念在开始之前，让我们先了解一些Drools的基本概念。

规则（Rule）：Drools中的规则是一个包含条件和操作的逻辑块。

规则通常以if-then形式表示，其中if部分是条件，then部分是执行操作。

事实（Fact）：Drools中的事实是规则的输入数据。

事实以Java对象的形式存在，可以包含一些属性和方法。

规则库（RuleBase）：Drools中的规则库是一组相关的规则，它负责管理和执行规则。

Drools的用法1. 引入Drools库首先，我们需要在项目中引入Drools库。

可以使用Maven或手动下载Drools 的jar文件。

在Java项目中，添加Drools库后，我们就可以开始使用Drools的功能了。

2. 创建规则接下来，我们需要定义规则。

规则使用Drools提供的DSL（规则定义语言）编写，也可以使用原生的Java代码编写。

下面是一个示例规则的DSL定义：rule "Discount Rule"when$order: Order(total > 1000)then$order.applyDiscount(0.1);end在上面的示例规则中，当订单的总价大于1000时，应用折扣。

3. 构建规则库一旦我们定义了规则，我们就可以将它们构建成规则库。

规则库负责管理和执行规则。

下面是构建规则库的示例代码：KnowledgeBuilder kBuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();kBuilder.add(ResourceFactory.newClassPathResource("rules.drl"), ResourceType.DRL);if (kBuilder.hasErrors()) {throw new RuntimeException("Error building knowledge base: " +kBuilder.getErrors());}KnowledgeBase kBase = KnowledgeBaseFactory.newKnowledgeBase();kBase.addPackages(kBuilder.getKnowledgePackages());在上面的示例代码中，我们使用KnowledgeBuilder来构建规则库。

Drools规则引擎初学入门实例HelloWorld2009-01-14 11:32（1）下载eclipse（），如果是一般的java开发，下载Eclipse IDE for Java Developers就行用；（2）下载Drools（/drools/downloads.html），目前最新版本是Drools 4.0.7 Binaries，下载后解（3）之后下载eclipse的Drools插件，版本跟eclipse对应，目前有Drools 4.0.7 Eclipse 3.2 Workbench和D Europa 3.3 Workbench两种。

Drools插件解压后，将里面的org.drools.eclipse_4.0.7.jar文件copy到eclipse的plugins目录中，重启可以看到一个图标，这就是Drools的工作台，之后就可通过这个按钮创建Drools resource文件了。

（4）开始Hello WorldJava文件：DroolsTest.java1. package com.sample;2.3. import java.io.InputStreamReader;4. import java.io.Reader;5.6. import org.drools.RuleBase;7. import org.drools.RuleBaseFactory;8. import org.drools.WorkingMemory;9. import piler.PackageBuilder;10. import org.drools.rule.Package;11.12. /**13. * This is a sample file to launch a rule package from a rule source file.14. */15. public class DroolsTest {16.17. public static final void main(String[] args) {18. try {19.20. //load up the rulebase21. RuleBase ruleBase = readRule();22. WorkingMemory workingMemory = ruleBase.newStatefulSession();23.24. //go !25. Message message = new Message();26. message.setMessage( "Hello World" );27. message.setStatus( Message.HELLO );28. workingMemory.insert( message );29. workingMemory.fireAllRules();30.31.32. } catch (Throwable t) {33. t.printStackTrace();34. }35. }36.37. /**38. * 读取规则文件39. * Please note that this is the "low level" rule assembly API.40. */41. private static RuleBase readRule() throws Exception {42. //read in the source43. Reader source = new InputStreamReader( DroolsTest.class.getResourceAsStream( "/Sample.drl" )44.45. //optionally read in the DSL (if you are using it).46. //Reader dsl = new InputStreamReader( DroolsTest.class.getResourceAsStream( "/mylang.dsl" ) );47.48. //Use package builder to build up a rule package.49. //An alternative lower level class called "DrlParser" can also be used...50.51. PackageBuilder builder = new PackageBuilder();52.53. //this wil parse and compile in one step54. //NOTE: There are 2 methods here, the one argument one is for normal DRL.55. builder.addPackageFromDrl( source );56.57. //Use the following instead of above if you are using a DSL:58. //builder.addPackageFromDrl( source, dsl );59.60. //get the compiled package (which is serializable)61. Package pkg = builder.getPackage();62.63. //add the package to a rulebase (deploy the rule package).64. RuleBase ruleBase = RuleBaseFactory.newRuleBase();65. ruleBase.addPackage( pkg );66. return ruleBase;67. }68.69. public static class Message {70. public static final int HELLO = 0;71. public static final int GOODBYE = 1;72. public static final int GAME_OVER = 2;74. private String message;75.76. private int status;77.78. public String getMessage() {79. return this.message;80. }81.82. public void setMessage(String message) {83. this.message = message;84. }85.86. public int getStatus() {87. return this.status;88. }89.90. public void setStatus( int status ) {91. this.status = status;92. }93. }94.95. }选择插件Drools按钮里的"New Rule resource"，建立规则（rule）文件：Sample.drl1. package com.sample2.3. import com.sample.DroolsTest.Message;4.5. rule "Hello World"6. when7. m : Message( status == Message.HELLO, message : message )8. then9. System.out.println( message );10. m.setMessage( "Goodbye cruel world" );11. m.setStatus( Message.GOODBYE );12. update( m );13. end14.15. rule "GoodBye"16. no-loop true17. when18. m : Message( status == Message.GOODBYE, message : message )20. System.out.println( message );21. m.setStatus(Message.GAME_OVER);22. m.setMessage("game over now!");23. update( m );24. end25.26. rule "game over"27. when28. m : Message( status == Message.GAME_OVER)29. then30. System.out.println( m.getMessage() );31. end注意：文件要放在相应的包里，然后编译—执行，当时出现了错误，查找资料，还需要加载包，包括：<1> Drools 4.0.7目录下的drools-core-4.0.7.jar，drools-compiler-4.0.7.jar<2> Drools 4.0.7\lib目录下的antlr-runtime-3.0.jar，mvel-1.3.1-java1.4.jar<3>以及eclipse\plugins目录下的org.eclipse.jdt.core_3.2.3.v_686_R32x.jar（不同版本，包名会稍有不同）。

1. 学习前的准备Drools是一款基于Java的开源规则引擎，所以在使用Drools之前需要在开发机器上安装好JDK环境，Drools5要求的JDK版本要在1.5或以上。

1.1.开发环境搭建大多数软件学习的第一步就是搭建这个软件的开发环境，Drools也不例外。

本小节的内容就是介绍如何搭建一个Drools5的开发、运行、调试环境。

1.1.1.下载开发工具Drools5提供了一个基于Eclipse3.4的一个IDE开发工具，所以在使用之前需要到网站下载一个 3.4.x版本的Eclipse，下载完成之后，再到/drools/downloads.html 网站，下载Drools5的Eclipse插件版IDE及Drools5的开发工具包，如图1-1所示。

除这两个下载包以外，还可以把Drools5的相关文档、源码和示例的包下载下来参考学习使用。

将下载的开发工具包及IDE包解压到一个非中文目录下，解压完成后就可以在Eclipse3.4上安装Drools5提供的开发工具IDE了。

1.1.2. 安装Drools IDE打开Eclipse3.4所在目录下的links目录（如果该目录不存在可以手工在其目录下创建一个links目录），在links目录下创建一个文本文件，并改名为drools5-ide.link，用记事本打开该文件，按照下面的版本输入Drools5 Eclipse Plugin文件所在目录：path=D:\\eclipse\\drools-5.0-eclipse-all这个值表示Drools5 Eclipse Plugin文件位于D盘eclipse目录下的drools-5.0-eclipse-all下面，这里有一点需要注意，那就是drools-5.0-eclipse-all文件夹下必须再包含一个eclipse 目录，所有的插件文件都应该位于该eclipse目录之下，接下来要在win dos下重启Eclipse 3.4，检验Drools5 IDE是否安装成功。

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();以上是一个简单的编译规则的示例代码。