概述(Overview)

以.drl为扩展名的文件，是Drools中的规则文件，规则文件的编写，遵循Drools规则语法。下面详细介绍一下Drools规则文件语法。具体参考官方文档： https://docs.jboss.org/drools/release/7.0.0.Final/drools-docs/html_single/index.html#_droolslanguagereferencechapter
DRL文件的整体结构如下：

package package-name

imports

globals

functions

queries

rules

对于上述元素，其顺序在drl文件中的顺序不重要，除了package-name，必须是drl文件的第一个元素。上述所有的元素都是可选的，接下来我们将详细介绍上述元素。

规则（Rule）组成

一个简单的规则结构如下所示：

rule "name"
    attributes
    when
        LHS
    then
        RHS
end

通常，规则文件中是不需要标点符号的。即使是规则名“name”上的双引号也是可选的。attributes展示规则的执行方式，也是可选的。LHS是规则的条件部分，遵循一个固定的语法规则，在下面的内容会详细介绍。RHS通常是一个可以本地执行的代码块。

关键字(Key Words)

从Drools 5开始，提出了“软”关键字和“硬”关键字的概念。硬关键字是保留的，不允许开发人员在编写规则文件时使用。硬关键字有如下几个：

• true
• false
• null

软关键字是在文件内容中公认的一些字，开发人员可以在任何地方使用这些关键字，但是为了消除混淆，并不推荐开发人员在实际中使用这些关键字。软关键字有如下几个：

• lock-on-active
• date-effective
• date-expires
• no-loop
• auto-focus
• activation-group
• agenda-group
• ruleflow-group
• entry-point
• duration
• package
• import
• dialect
• salience
• enabled
• attributes
• rule
• extend
• when
• then
• template
• query
• declare
• function
• global
• eval
• not
• in
• or
• and
• exists
• forall
• accumulate
• collect
• from
• action
• reverse
• result
• end
• over
• init

注释(Comments)

注释是规则文件中一段会被规则引擎自动忽略的一段文本。drl文件中的注释采用类Java语法的方式，可以分为两类：单行注释和多行注释。

单行注释

单行注释可以简单的使用双斜杠"//"来标识。语法解析器会自动忽视其后的所有内容。样例如下：

rule "Testing Comments"
when
    // this is a single line comment
    eval( true ) // this is a comment in the same line of a pattern
then
    // this is a comment inside a semantic code block
end

另外需要注意的是，“#”开头的单行注释在drl文件中已经被弃用。

多行注释

多行注释主要用于在代码块外对整个文件进行注释，以"/"开头和"/"结尾的之间所有的内容都会被语法解析器解释为注释。样例如下：

rule "Test Multi-line Comments"
when
    /* this is a multi-line comment
       in the left hand side of a rule */
    eval( true )
then
    /* and this is a multi-line comment
       in the right hand side of a rule */
end

错误信息(Error Messages)

Drools 5 开始提出了标准的错误信息。标准化的目的是为了使开发者可以更准确更简单定位错误问题所在。接下来将介绍如正确理解和识别错误信息。

错误信息格式

标准的错误信息格式如下所示。

ErrorMessageFormat.png

错误信息包含以下几个部分：

• 1st Block: 表明当前错误的错误码。
• 2st Block: 错误可能发生的行和列。
• 3st Block: 错误信息描述。
• 4st Block: 指明错误发生的规则，函数，模板，查询等。
• 5st Block: 指明错误发生于何种模式。一般不是强制性的。

错误码描述

• 101: No viable alternative
  错误码101指明了最常见的错误，语法解析器无法找到替代方案。下面有一些常见的例子：

1: rule one
2:   when
3:     exists Foo()
4:     exits Bar()  // "exits"
5:   then
6: end

上述示例会产生如下错误信息：

• [ERR 101] Line 4:4 no viable alternative at input 'exits' in rule one

上述例子中的exits != exists, 解析器找不到exits的替代方案，于是报错。下面我们可以再看一个例子。

1: package org.drools.examples;
2: rule
3:   when
4:     Object()
5:   then
6:     System.out.println("A RHS");
7: end

现在，上述的代码会产生如下错误信息：

• [ERR 101] Line 3:2 no viable alternative at input 'WHEN'

这里when是一个关键字，语法解析器在这里会遇到一个问题：rule没有文件名，而when是一个规则的条件部分。因此报错。下面还有一个相同类型错误的示例：

1: rule simple_rule
2:   when
3:     Student( name == "Andy )
4:   then
5: end

这里双引号缺少了另一半，因此会报错。

• 102: Mismatched input
  该错误表明，语法解析器在当前输入位置中未找到一个特定的符号。下面有一些例子：

1: rule simple_rule
2:   when
3:     foo3 : Bar(

上述示例会产生如下错误：

• [ERR 102] Line 0:-1 mismatched input '<eof>' expecting ')' in rule simple_rule in pattern Bar

要解决上述问题，需要完善上述规则语句。接下来的实例会产生多个错误：

1: package org.drools.examples;
2:
3: rule "Avoid NPE on wrong syntax"
4:   when
5:     not( Cheese( ( type == "stilton", price == 10 ) || ( type == "brie", price == 15 ) ) from $cheeseList )
6:   then
7:     System.out.println("OK");
8: end

上述代码会产生如下错误：

• [ERR 102] Line 5:36 mismatched input ',' expecting ')' in rule "Avoid NPE on wrong syntax" in pattern Cheese
• [ERR 101] Line 5:57 no viable alternative at input 'type' in rule "Avoid NPE on wrong syntax

 该错误信息与前一个错误相关，这里只需要将```,```用```&&```替换就好了。

* **103: Failed predicate**
出现该错误信息的原因是一个验证的语义谓词被验证为false。通常这些语义谓词用于识别软关键字。以下是一个示例：

1: package nesting;
2: dialect "mvel"
3:
4: import org.drools.compiler.Person
5: import org.drools.compiler.Address
6:
7: fdsfdsfds
8:
9: rule "test something"
10: when
11: p: Person( name=="Michael" )
12: then
13: p.name = "other";
14: System.out.println(p.name);
15: end

我们可以得到如下错误信息：
  * ```[ERR 103] Line 7:0 rule 'rule_key' failed predicate: {(validateIdentifierKey(DroolsSoftKeywords.RULE))}? in rule

fdsfdsfds是个无效的关键字，语法解析器无法将其识别成一个软关键字。

• 104: Trailing semi-colon not allowed
  该错误信息与eval从句相关，当分号不是出现在其表达式的结尾时可能报此错误。可以看一下如下示例。

1: rule simple_rule
2:   when
3:     eval(abc();)
4:   then
5: end

由于在eval中以分号结尾，我们可以得到如下错误信息：

• [ERR 104] Line 3:4 trailing semi-colon not allowed in rule simple_rule

该错误很容易修复，只要移除eval中的分号即可。

• 105: Early Exit
  drl文件中的子规则至少能被匹配选择一次，但是当子规则不能匹配任何东西的时候，就会报这个错。
  以下是一个示例：

1: template test_error
2:   aa s  11;
3: end

该示例会报以下错误信息：

• [ERR 105] Line 2:2 required (…​)+ loop did not match anything at input 'aa' in template test_error

• Other Messages
  开发中可能还会遇到一些其他意想不到的问题，这些问题可以向Drools的开发团队求助。

包(Package)

package是一系列rule或其他相关构件如imports, globals的容器。这个成员之间相互关联，一个package代表了一个命名空间，其中的每个rule的名字都是唯一的，package名字本身就是命名空间，与实际的文件和文件夹没有任何关系。常见的结构是，一个文件包含多个rule的文件就定义成一个包。以下的线路图表明了一个包中包含的所有组成元素。

package.png

import

Drools文件中的import语句功能与Java中的import语句功能类似。使用import时，必须指定对象的全称限定路径和类型名。Drools会自动导入Java相同名字的包中的所有类，也会导入java.lang.*。

global

global.png

1. 在规则文件中定义常量，并使用这些常量。

global java.util.List myGlobalList;
rule "Using a global"
when
    eval( true )
then
    myGlobalList.add( "Hello World" );
end

2. 在工作内存中，为全局变量设值。在从内存中获取所有的fact之前，最好将所有的全局变量设置。例如：

List list = new ArrayList();
KieSession kieSession = kiebase.newKieSession();
kieSession.setGlobal( "myGlobalList", list );

全局变量并不是用来在规则间共享数据，而且最好不要用于在规则间共享数据。规则总是对工作内存的状态产生推理和反应，因此，如果想在规则之间传递数据，可以将这些数据作为facts传入工作内存。因为规则引擎并不会关心和跟踪这些全局变量的变化。

函数(Function)

function.png

function String hello(String name) {
    return "Hello "+name+"!";
}

需要注意的是，这里我们使用了function关键字，即使它并不是Java语言的一部分。参数和返回值的定义和传入与Java语言一致。当然，参数和返回值并不是必须的。另外，我们可以使用一个帮助类中的静态方法，如：Foo.hello()。
  Drools支持函数的导入，我们所要做的就是：

import function my.package.Foo.hello

不需要考虑函数的定义和导入方式，我们可以直接在需要的地方直接使用函数名调用这个函数。例如：

rule "using a static function"
when
    eval( true )
then
    System.out.println( hello( "Bob" ) );
end

类型声明(Type Declaration)

在规则引擎中，类型声明有两个目的：允许新的类型声明；允许元数据类型的声明。

• 声明新类型：Drools工作时会将外部的普通Java对象作为事实。但是有时候使用者想要自己定义一些规则引擎可以直接使用的模型，而不用担心用Java之类的底层语言来创建对象。另外有时候，当一个域模型已经建立，但是用户想或者需要用一些主要在推理过程中使用的实体来完善这个模型。
• 声明元数据：事实往往会有一些与之相关的元数据信息。元信息的样本包含的任何种类的数据都不能代表事实的属性，且在该事实类型的所有实例中都是不变的。这些元信息在规则引擎的运行和推理古城中需要被查询。

声明新类型

为了定义新类型，我们需要使用关键字``declare，然后是一系列域，最终以end关键字结尾。一个新的fact必须有一系列域，否则规则引擎会去classpath中寻找一个存在的fact```类，如果没找到，会报错。下面给出定义新类型的几个例子。

Example . Declaring a new fact type: Address

declare Address
   number : int
   streetName : String
   city : String
end

上面的例子中我们定义了一个新类型Address，这个fact有三个属性，每个属性都具有一个Java中有效的数据类型。同样的，我们可以再定义一个数据类型：
Example . Declaring a new fact type: Person

declare Person
    name : String
    dateOfBirth : java.util.Date
    address : Address
end

我们可以看一下上面的例子，dateOfBirth是Java中的java.util.Date类型，address是我们刚才声明的类型。为了不用写全称限定名，我们可以先使用import来导入要使用的类型，例如：
Avoiding the need to use fully qualified class names by using import

import java.util.Date

declare Person
    name : String
    dateOfBirth : Date
    address : Address
end

当我们声明一个新的fact类型时，Drools会在编译期间生成实现自一个表示该fact类型的Java类的字节码。这个生成的Java类

Example : generated Java class for the previous Person fact typedeclaration

public class Person implements Serializable {
    private String name;
    private java.util.Date dateOfBirth;
    private Address address;

    // empty constructor
    public Person() {...}

    // constructor with all fields
    public Person( String name, Date dateOfBirth, Address address ) {...}

    // if keys are defined, constructor with keys
    public Person( ...keys... ) {...}

    // getters and setters
    // equals/hashCode
    // toString
}

该类型生成的class是一个普通的Java类，可以在规则中直接使用，就向其他 fact一样。见如下例子：
Using the declared types in rules

rule "Using a declared Type"
when
    $p : Person( name == "Bob" )
then
    // Insert Mark, who is Bob's mate.
    Person mark = new Person();
    mark.setName("Mark");
    insert( mark );
end

声明枚举类型

DRL同时支持声明枚举类型。该类型声明需要另外一种关键字enum，然后以都好分割可接收值的列表，最后以分号结束。

declare enum DaysOfWeek
   SUN("Sunday"),MON("Monday"),TUE("Tuesday"),WED("Wednesday"),THU("Thursday"),FRI("Friday"),SAT("Saturday");

   fullName : String
end

声明完成之后，该枚举类型可以用于之后的规则中。

rule "Using a declared Enum"
when
   $p : Employee( dayOff == DaysOfWeek.MONDAY )
then
   ...
end

声明元数据

在Drools中元数据会被分配给一系列不同对象的构造：fact类型，fact属性和规则。Drools使用@符号来引出元数据，使用使用如下格式：

@metadata_key( metadata_value )

其中metadata_value是可选的。
   Drools允许声明任何任意元数据属性，但是当其他属性在运行时仅仅对查询有效时，有些属性对于规则引擎来说具有不同的意义。Drools允许为fact类型和fact属性声明元数据。所有的元数据在该属性被分配到fact类型前声明，而在向一个特定属性分配值之前声明。
Example 115. Declaring metadata attributes for fact types and attributes

import java.util.Date

declare Person
    @author( Bob )
    @dateOfCreation( 01-Feb-2009 )

    name : String @key @maxLength( 30 )
    dateOfBirth : Date
    address : Address
end

上面的例子中，声明了两个fact类型(@author 和 @dateOfCreation)的元数据元素，另外为name属性声明了两个(@key和@maxLength)元数据。其中@key没有必须值，所有括号和值均被省略了。

规则(Rule)

rule.png

Example . Rule Syntax Overview

rule "<name>"
    <attribute>*
when
    <conditional element>*
then
    <action>*
end

Example . A simple rule

rule "Approve if not rejected"
  salience -100
  agenda-group "approval"
    when
        not Rejection()
        p : Policy(approved == false, policyState:status)
        exists Driver(age > 25)
        Process(status == policyState)
    then
        log("APPROVED: due to no objections.");
        p.setApproved(true);
end

rule attributes.png

规则属性

规则属性显式地声明了对规则行为的影响，有些规则属性很简单，有些规则属性是复杂的子系统的一部分，如规则流。为了从Drools中获得更多东西，我们需要确保对每一个规则属性均有正确的认识。
常用的规则属性有如下：

• no-loop

  • 默认值：false
  • type: Boolean
    当规则序列更改了一个fact，会导致该规则会被重新触发，以至于产生一个无限循环。当设置为true时，当前规则只会被激活一次。

• ruleflow-group

  • 默认值：N/A
  • type: String
    ruleflow是Drools的特色之一，可以让你自己控制规则的命中。同一个ruleflow-group中的所有规则只有当该组激活时才能被命中。

• lock-on-active

  • 默认值：false
  • type: Boolean
    不管何时ruleflow-group和agenda-group被激活，只要其中的所有规则将lock-on-active设置为true，那么这些规则都不会再被激活，不管一开始怎么更新，这些匹配的规则都不会被激活。这是no-loop属性的增强，因为这些变化现在不仅仅是规则自身的变化。

• salience

  • 默认值：0
  • type: Integer
    任何规则都有一个默认为0的salience属性，该属性可以为0，正数和负数。salience表示规则的优先级，值越大其在激活队列中的优先级越高。Drools支持使用动态的salience，可以使用一个包含动态约束变量的表达式来表示。如下所示
    Dynamic Salience

rule "Fire in rank order 1,2,.."
        salience( -$rank )
    when
        Element( $rank : rank,... )
    then
        ...
end

• agenda-group

  • 默认值：MAIN
  • type: String
    agenda-group允许用户将Agenda分割成多个部分以提供更多的运行控制。

• auto-focus

  • 默认值：false
  • type: Boolean
    当一个规则被激活时auto-focus为true，而且该规则的agenda-group还没有focus，当该agenda-groupfocus时，允许该规则潜在命中。

• activation-group

  • 默认值：N/A
  • type: String
    属于同一个activation-group的规则会进行唯一命中。也就是说同一个activation-group中的规则，只要有一个命中，其他的规则都会被取消激活状态，这样这些规则就不会被命中。

• dialect

  • 默认值：as specified by the package
  • type: String
    dialect用于指明规则中使用的代码的语言种类，目前支持两种语言，"java"或"mvel"。

• date-effective

  • 默认值：N/A
  • type: String (包含日期和时间)
    当前系统时间在date-effective之后，该规则才会被激活。

• date-effective

  • 默认值：N/A
  • type: String (包含日期和时间)
    当前系统时间在date-effective之后，该规则不会再被激活。

• duration

  • 默认值：无
  • type: long (包含日期和时间)
    duration用于表示一个规则在一定时间之后才会被命中，如果它还是激活状态的话。

LHS语法

LHS是规则的条件部分的统称，由零到多条条件元素组成。如果LHS为空，默认为是条件部分一直为true。当一个新的WorkingMemory session创建的时候，会被激活和触发。
Example. Rule without a Conditional Element

rule "no CEs"
when
    // empty
then
    ... // actions (executed once)
end

// The above rule is internally rewritten as:

rule "eval(true)"
when
    eval( true )
then
    ... // actions (executed once)
end

LHS中的条件元素基于一个或多个模式，最常用的条件元素是and。当然如果LHS中有多个不互相连接的模式时，默认使用隐式的and。
Implicit and

rule "2 unconnected patterns"
when
    Pattern1()
    Pattern2()
then
    ... // actions
end

// The above rule is internally rewritten as:

rule "2 and connected patterns"
when
    Pattern1()
    and Pattern2()
then
    ... // actions
end

模式
模式是最终要的条件元素，它可以隐式地匹配所有插入到WorkingMemory中的所有fact。一个模式具有0个或多个约束条件和一个可选的模式组合。模式的结构图如下所示：

Pattern.png

Person()

这里的类型为Person，该模式意味着将匹配WorkingMemory中的所有Person对象。该类型不需要是一个真实 fact对象的类。模式可以指向超类甚至是接口，这样可以匹配多个不同类的facts。例如：

Object() // matches all objects in the working memory

模式的括号中条件定义了模式在何种条件下满足。如下所示：

Person( age == 100 )

为了引用匹配的对象，可以使用一个模式绑定参数如：$p。
Example . Pattern with a binding variable

rule ...
when
    $p : Person()
then
    System.out.println( "Person " + $p );
end

$符号是非强制性的，只是用于在复杂的规则中方便标识，将其与变量及域区分开来。
约束

• 什么是约束？

约束是一个返回true或false的表达式，如下例所示：

Person( 5 < 6 )  // just an example, as constraints like this would be useless in a real pattern

约束本质上是一个与Java表达式稍微有点不同的表达式，例如equals()等价于==。接下来我们深入理解一下。

• Java Beans属性获取。

任何一个bean的属性都可以被直接使用，bean属性的获取也可以使用标准的Java bean getter: getMyProperty() or isMyProperty()。例如：

//use directly
Person( age == 50 )

// this is the same as:
Person( getAge() == 50 )

同时，Drools还支持嵌套的属性获取方式，如：

//use directly
Person( address.houseNumber == 50 )

// this is the same as:
Person( getAddress().getHouseNumber() == 50 )

当然，约束中的条件表达式是支持Java表达式的，下面几个例子都是正确的：

Person( age == 50 )
Person( age > 100 && ( age % 10 == 0 ) )
Person( Math.round( weight / ( height * height ) ) < 25.0 )

• 逗号分隔符 AND

逗号分隔约束，具有隐含的AND的含义。

// Person is at least 50 and weighs at least 80 kg
Person( age > 50, weight > 80 )

// Person is at least 50, weighs at least 80 kg and is taller than 2 meter.
Person( age > 50, weight > 80, height > 2 )

逗号运算符不能出现在复合的约束表达式中，如

// Do NOT do this: compile error
Person( ( age > 50, weight > 80 ) || height > 2 ) 

// Use this instead
Person( ( age > 50 && weight > 80 ) || height > 2 )

• 绑定变量

属性值可以绑定到一个变量中：

// 2 persons of the same age
Person( $firstAge : age ) // binding
Person( age == $firstAge ) // constraint expression

• 分组访问嵌套对象属性

可以先看一个例子：

Person( name == "mark", address.city == "london", address.country == "uk" )

Person( name == "mark", address.( city == "london", country == "uk") )

也就是对嵌套对象属性的访问，可以组合在一个括号里面。

• 内联强制类型转换

当处理嵌套对象时，往往需要将其转换成子类，可以通过使用#符号来完成。如下例所示：

Person( name == "mark", address#LongAddress.country == "uk" )

在该例子中将 Address转换成LongAddress。如果类型转换失败，该值会被认为是false。当然，类型转换也支持全称限定名称。如下所示：

Person( name == "mark", address#org.domain.LongAddress.country == "uk" )

当然，在同一个表达式中使用多级内联转换也是可行的。如下所示：

Person( name == "mark", address#LongAddress.country#DetailedCountry.population > 10000000 )

另外，Drools同样支持instanceof操作。

Person( name == "mark", address instanceof LongAddress, address.country == "uk" )

• 特殊文字支持
  除了正常的Java文字，Drools还支持以下特殊的文字：
  • 日期文字。

查询(Query)

Domain Specific Languages