流口水可执行模型

可执行模型是对引擎处理的Drools最低级别模型的重新设计。 在当前的系列（最多6.x）中，可执行模型在过去的8年中有机地增长了，从未真正成为最终用户的目标。 建议那些希望以编程方式编写规则的人通过代码生成和目标drl来完成； 这是不理想的。 从来没有任何驱动程序可以使最终用户更容易地使用它，因为在Java中广泛使用匿名类非常麻烦。 借助Java 8和Lambda的这种变化，就有可能制造出最终用户可以访问的更具吸引力的模型。

这个新模型是在高级语言的编译过程中生成的，但是也可以单独使用。 我们的目标是使该可执行模型自成一体，并避免进行进一步的字节码修改（分析，转换或生成）； 从该模型的角度来看，所有内容均由代码或高级语言层提供。 例如，索引等必须由参数提供，高级语言在针对可执行模型时会通过分析生成这些参数。

它旨在利用Java 8的lambda很好地映射到Fluent级别的构建者。 这将使其对Java开发人员和语言开发人员更具吸引力。 而且，这将允许独立于任何语言的低级引擎功能设计和测试。 这意味着我们可以在引擎级别进行创新，而不必担心语言层。

可执行模型应该足够通用以映射到多个域。 这将是一个低级数据流模型，您可以在其中处理功能性反应式编程模型，但仍可用于从中构建基于规则的系统。

以下示例提供了用于构建可执行模型的流利DSL的第一个视图：

DataSource persons = sourceOf(new Person("Mark", 37),
                              new Person("Edson", 35),
                              new Person("Mario", 40));
                     
Variable<Person> markV = bind(typeOf(Person.class));

Rule rule = rule("Print age of persons named Mark")
        .view(
            input(markV, () -> persons),
            expr(markV, person -> person.getName().equals("Mark"))
        )
        .then(
            on(markV).execute(mark -> System.out.println(mark.getAge())
        )
);

前面的代码定义了一个包含一些人员实例的数据源，并声明了人员类型的变量markV。 规则本身包含通常的两部分：LHS由传递给view（）方法的一组输入和表达式定义，而RHS是由传递给then（）方法的lambda表达式定义的动作。

更详细地分析LHS，语句如下：

input(markV, () -> persons)

将人员数据源中的对象绑定到markV变量，并通过对象类进行模式匹配。 从这个意义上讲，DataSource可以被视为等同于Drools入口点。

相反的表达：

expr(markV, person -> person.getName().equals("Mark"))

使用谓词定义绑定到markV变量的对象必须满足的条件才能被引擎成功匹配。 请注意，正如预期的那样，模式匹配的评估不是通过由任何种类的分析或编译过程产生的约束来执行的，而是仅通过应用实现谓词的lambda表达式来执行（在这种情况下，人员- > person.getName（）。equals（“ Mark”））匹配的对象。 换句话说，前一个DSL会生成一个规则的可执行模型，该模型等效于后续drl的解析结果。

rule "Print age of persons named Mark"
when
    markV : Person( name == "Mark" ) from entry-point "persons"
then
    System.out.println(markV.getAge());
end

它还正在开发一个rete构建器，可以使用此DSL定义的规则。 特别是，可以将这些规则添加到CanonicalKieBase中，然后像其他任何普通KieBase一样从中创建KieSession。

CanonicalKieBase kieBase = new CanonicalKieBase();
kieBase.addRules(rule);

KieSession ksession = kieBase.newKieSession();
ksession.fireAllRules();

当然，DSL还允许定义更复杂的条件，例如连接：

Variable<Person> markV = bind(typeOf(Person.class));
Variable<Person> olderV = bind(typeOf(Person.class));

Rule rule = rule("Find persons older than Mark")
        .view(
            input(markV, () -> persons),
            input(olderV, () -> persons),
            expr(markV, mark -> mark.getName().equals("Mark")),
            expr(olderV, markV, (older, mark) -> older.getAge() > mark.getAge())
        )
        .then( 
            on(olderV, markV)
                .execute((p1, p2) -> System.out.println(p1.getName() + " is older than " + p2.getName())
        )
);

或存在模式：

Variable<Person> oldestV = bind(typeOf(Person.class));
Variable<Person> otherV = bind(typeOf(Person.class));

Rule rule = rule("Find oldest person")
        .view(
            input(oldestV, () -> persons),
            input(otherV, () -> persons),
            not(otherV, oldestV, (p1, p2) -> p1.getAge() > p2.getAge())
        )
        .then( 
            on(oldestV)
                .execute(p -> System.out.println("Oldest person is " + p.getName())
        )
);

这里的not（）代表所有表达式的取反，因此上面使用的形式实际上只是以下内容的快捷方式：

not( expr( otherV, oldestV, (p1, p2) -> p1.getAge() > p2.getAge() ) )

还已经以以下形式支持累计：

Variable<Person> person = bind(typeOf(Person.class));
Variable<Integer> resultSum = bind(typeOf(Integer.class));
Variable<Double> resultAvg = bind(typeOf(Double.class));

Rule rule = rule("Calculate sum and avg of all persons having a name starting with M")
        .view(
            input(person, () -> persons),
            accumulate(expr(person, p -> p.getName().startsWith("M")),
                       sum(Person::getAge).as(resultSum),
                       avg(Person::getAge).as(resultAvg))
        )
        .then(
            on(resultSum, resultAvg)
                .execute((sum, avg) -> result.value = "total = " + sum + "; average = " + avg)
);

为了提供最后一个更完整的用例，可以使用此DSL定义经典火灾和警报示例的可执行模型，如下所示。

Variable<Room> room = any(Room.class);
Variable<Fire> fire = any(Fire.class);
Variable<Sprinkler> sprinkler = any(Sprinkler.class);
Variable<Alarm> alarm = any(Alarm.class);

Rule r1 = rule("When there is a fire turn on the sprinkler")
        .view(
            input(fire),
            input(sprinkler),
            expr(sprinkler, s -> !s.isOn()),
            expr(sprinkler, fire, (s, f) -> s.getRoom().equals(f.getRoom()))
        )
        .then(
            on(sprinkler)
                .execute(s -> {
                    System.out.println("Turn on the sprinkler for room " + s.getRoom().getName());
                    s.setOn(true);
                })
                .update(sprinkler, "on")
);

Rule r2 = rule("When the fire is gone turn off the sprinkler")
        .view(
            input(sprinkler),
            expr(sprinkler, Sprinkler::isOn),
            input(fire),
            not(fire, sprinkler, (f, s) -> f.getRoom().equals(s.getRoom()))
        )
        .then(
            on(sprinkler)
                .execute(s -> {
                    System.out.println("Turn off the sprinkler for room " + s.getRoom().getName());
                    s.setOn(false);
                })
                .update(sprinkler, "on")
);

Rule r3 = rule("Raise the alarm when we have one or more fires")
        .view(
            input(fire),
            exists(fire)
        )
        .then(
            execute(() -> System.out.println("Raise the alarm"))
                .insert(() -> new Alarm())
);

Rule r4 = rule("Lower the alarm when all the fires have gone")
        .view(
            input(fire),
            not(fire),
            input(alarm)
        )
        .then(
            execute(() -> System.out.println("Lower the alarm"))
                .delete(alarm)
);

Rule r5 = rule("Status output when things are ok")
        .view(
            input(alarm),
            not(alarm),
            input(sprinkler),
            not(sprinkler, Sprinkler::isOn)
        )
        .then(
            execute(() -> System.out.println("Everything is ok"))
);

CanonicalKieBase kieBase = new CanonicalKieBase();
kieBase.addRules(r1, r2, r3, r4, r5);

KieSession ksession = kieBase.newKieSession();

// phase 1
Room room1 = new Room("Room 1");
ksession.insert(room1);
FactHandle fireFact1 = ksession.insert(new Fire(room1));
ksession.fireAllRules();

// phase 2
Sprinkler sprinkler1 = new Sprinkler(room1);
ksession.insert(sprinkler1);
ksession.fireAllRules();

assertTrue(sprinkler1.isOn());

// phase 3
ksession.delete(fireFact1);
ksession.fireAllRules();

在此示例中，可能还要注意几件事：

• 必须执行一些重复操作才能将表达式的参数绑定到评估它的lambda表达式的形式参数。 希望可以在解决此JDK错误时使用-parameters编译参数来克服此问题。
• any（Room.class）是bind（typeOf（Room.class））的快捷方式
• 输入未声明数据源。 这是指出这些对象来自默认空DataSource的快捷方式（对应于Drools默认入口点）。 实际上，在此示例中，事实以编程方式插入到KieSession中。
• 使用输入而不为其提供任何表达式的输入实际上是input（alarm），expr（alarm，a-> true）的快捷方式
• 以同样的方式，没有条件的存在模式，例如not（fire）是not（expr（fire，f-> true））的另一个快捷方式
• Java 8语法还允许将谓词定义为访问诸如expr（sprinkler，Sprinkler :: isOn）之类的事实的布尔属性的方法引用。
• RHS与要执行的代码块一起，还提供了一个流畅的接口来定义在触发规则时必须执行的工作内存操作（插入/更新/删除）。 特别是，更新还获得了一个字符串变量，用于报告在更新的事实中更改过的属性的名称，例如update（sprinkler，“ on”）。 再次必须明确提供此信息，因为必须创建可执行模型而无需任何代码分析。

翻译自: https://www.javacodegeeks.com/2014/07/drools-executable-model.html