Drools规则文件中自定义集合比较操作的方法与技巧

摘要：在Drools规则文件中，可以通过自定义集合比较操作来处理复杂的业务逻辑。用户可以定义自己的集合类型和比较操作符，以便在规则引擎中执行更灵活的逻辑判断。通过这种方式，可以有效地提高Drools规则的灵活性和可维护性，从而更好地满足业务需求。

本文深入探讨了Drools规则引擎中处理集合类型数据的高级比较操作。我们将学习如何使用contains和memberOf进行基础的单值集合检查，以及如何通过组合多个条件实现“多对多”匹配。对于更复杂的场景，例如精确的集合内容匹配或自定义集合过滤逻辑，文章将详细介绍如何利用accumulate语句实现。

引言：Drools中集合比较的挑战

在Drools规则引擎中，对事实（Fact）对象中的集合类型字段进行匹配和过滤是常见的需求。例如，一个Test对象可能包含一个contactNumbers列表，我们希望规则能够根据这个列表的内容进行触发。然而，直接使用MVEL表达式进行集合间的复杂比较（如["1234", "5678"] contains contactNumbers）往往无法按预期工作，因为Drools的内置操作符contains和memberOf有其特定的语义。

为了更好地理解和演示，我们首先定义一个简单的Java Fact类：

// Test Fact Class
package com.abc;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.util.List;

@Data
@AllArgsConstructor
public class Test {
    private String name;
    private List<String> contactNumbers;
}

基础集合操作：contains 与 memberOf

Drools提供了两个基本的关键字来处理集合与单个值之间的关系：contains 和 memberOf。

1. contains：检查集合中是否包含某个值 当你的事实对象中有一个集合字段，你想检查这个集合是否包含某个特定的值时，可以使用contains。 语法：Fact( collectionField contains "value" ) 这表示collectionField这个集合中必须至少包含一个与"value"相等元素。

   示例：

   rule "Check if contactNumbers contains '1234'"
     when
       t : Test( contactNumbers contains "1234" );
     then
       System.out.println("Fact contains contact number 1234");
   end;

2. memberOf：检查某个值是否属于集合 当你的规则中有一个值，你想检查这个值是否属于事实对象的某个集合字段时，可以使用memberOf。通常，memberOf用于检查一个变量（或字面量）是否在一个集合中。 语法：Fact( fieldName memberOf collection ) 或 Fact( "value" memberOf collectionField )

   示例：

   rule "Check if 'Jim' is a member of ClassMates names"
     when
       $name: String( this == "Jim" ) // 假设有一个名为 Jim 的字符串事实
       c: ClassMates( $name memberOf names ) // names 是 ClassMates 事实的一个 List<String> 字段
     then
       System.out.println("Jim is a classmate.");
   end;

   对于我们的Test类，如果想检查一个特定的号码（例如"1111"）是否在某个Test实例的contactNumbers中，contactNumbers contains "1111"是更直接和常用的方式。memberOf在规则中定义一个列表并检查事实字段是否在此列表中时更常见，例如 Person( city memberOf ("New York", "London") )。

   

实现多对多（AND逻辑）匹配

在许多场景下，我们需要检查一个集合是否同时包含多个特定的值。例如，我们想找到所有contactNumbers既包含"1234"又包含"5678"的Test对象。

Drools并没有直接提供一个操作符来比较两个集合的“包含”关系（例如，规则中定义的List是否完全包含在事实的List中）。但我们可以通过组合多个contains条件来实现“多对多”的逻辑AND匹配。

正确实现方式： 通过在when部分的同一个模式（Pattern）中列出多个contains条件，它们之间默认是逻辑与（AND）关系。

rule "M1 rule-data matches fact - Multi-contains"
  when
    p : Test( contactNumbers contains "1234",
              contactNumbers contains "5678" );
  then
    System.out.println("M1 rule-data matches fact FOUND: contains both 1234 and 5678");
end;

这条规则会触发，当且仅当p这个Test事实的contactNumbers列表中同时包含"1234"和"5678"。列表中可能还包含其他号码，但这不影响规则的触发。

注意事项： 原始问题中尝试的Test( ["1234", "5678"] contains contactNumbers )和Test( contactNumbers contains ["1234", "5678"] )之所以不工作，是因为contains操作符期望右侧是一个单值，而不是一个集合。

高级集合过滤：精确集合匹配与自定义逻辑 (accumulate)

上述方法可以检查集合是否包含多个特定元素，但如果我们需要更严格的匹配，例如：

• 集合必须只包含指定的这些元素，不能有额外的。
• 需要对集合中的元素进行聚合计算或更复杂的过滤。

这时，accumulate语句就派上用场了。accumulate允许我们对一个或多个事实进行迭代、过滤和聚合，并将结果绑定到一个新的变量上。

示例：精确集合内容匹配

假设我们希望找到contactNumbers列表精确地包含"1234"和"5678"这两个号码，且不包含其他任何号码的Test对象。我们可以结合accumulate、collectSet和size检查来实现。

rule "Exact match for contactNumbers set"
  when
    $t: Test( $numbers: contactNumbers ) // 绑定 contactNumbers 列表到 $numbers 变量
    // 使用 accumulate 收集 $numbers 中在 ("1234", "5678") 列表中的元素
    $matchedNumbers: Set( size == $numbers.size() ) // 检查收集到的集合大小是否与原始集合大小相同
                 from accumulate(
                   $n: String(this memberOf ("1234", "5678")) // 过滤出 $numbers 中在目标集合中的号码
                   from $numbers, // 遍历 $numbers 列表
                   collectSet($n) // 将符合条件的号码收集到一个 Set 中
                 )
  then
    System.out.println("Exact match found for contactNumbers: " + $t.getName());
end;

解释：

1. $t: Test( $numbers: contactNumbers ): 首先匹配一个Test事实，并将其contactNumbers列表绑定到$numbers变量。
2. from accumulate(...): 这是一个聚合操作。
   • $n: String(this memberOf ("1234", "5678")) from $numbers: 遍历$numbers列表中的每一个字符串$n。this memberOf ("1234", "5678")确保$n必须是"1234"或"5678"中的一个。
   • collectSet($n): 将所有符合条件的$n收集到一个Set中，这样可以自动处理重复项。这个Set就是$matchedNumbers。
3. $matchedNumbers: Set( size == $numbers.size() ): 最后，我们检查$matchedNumbers这个集合的大小是否与原始$numbers列表的大小相同。如果相同，则意味着$numbers中的所有元素都在目标集合("1234", "5678")中，并且没有其他额外的元素。

完整示例代码

为了更好地理解上述规则，以下是完整的Java代码和DRL规则文件示例。

Test.java (Fact Class):

package com.abc;

import lombok.AllArgsConstructor;
import lombok.Data;
import java.util.List;

@Data
@AllArgsConstructor
public class Test {
    private String name;
    private List<String> contactNumbers;
}

rules.drl (DRL 规则文件):

package com.abc;

import com.abc.Test;
import java.util.Set; // accumulate collectSet 需要引入 Set

rule "name-rule"
  when
    t : Test( name == "abc" );
  then
    System.out.println("abc found by name-rule");
end;

// 检查 contactNumbers 是否包含 "1111"
rule "Check if contactNumbers contains '1111'"
  when
    t : Test( contactNumbers contains "1111" );
  then
    System.out.println("Fact contains contact number 1111: " + t.getName());
end;

// 检查 contactNumbers 是否同时包含 "1234" 和 "5678" (AND 逻辑)
rule "M1 rule-data matches fact - Multi-contains (AND)"
  when
    p : Test( contactNumbers contains "1234",
              contactNumbers contains "5678" );
  then
    System.out.println("M1 rule-data matches fact FOUND: contains both 1234 and 5678 for " + p.getName());
end;

// 精确匹配 contactNumbers 集合，必须只包含 "1234" 和 "5678"
rule "Exact match for contactNumbers set"
  when
    $t: Test( $numbers: contactNumbers )
    $matchedNumbers: Set( size == $numbers.size(), size == 2 ) // size == 2 进一步确认原始集合大小
                 from accumulate(
                   $n: String(this memberOf ("1234", "5678"))
                   from $numbers,
                   collectSet($n)
                 )
  then
    System.out.println("Exact match found for contactNumbers (1234, 5678) for: " + $t.getName());
end;

Main 方法片段 (Java):

import org.kie.api.KieServices;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import com.abc.Test;
import java.util.Arrays;
import java.util.List;

public class DroolsCollectionComparison {
    public static void main(String[] args) {
        KieServices ks = KieServices.Factory.get();
        KieContainer kc = ks.getKieClasspathContainer();
        KieSession kieSession = kc.newKieSession("ksession-rules"); // 假设你的 kmodule.xml 配置了 ksession-rules

        // 创建 Fact 对象
        Test t1 = new Test("abc", Arrays.asList("1111")); // 包含 "1111"
        Test t2 = new Test("xyz", Arrays.asList("1234", "5678", "2222")); // 包含 "1234", "5678", "2222"
        Test t3 = new Test("pqr", Arrays.asList("1234", "5678")); // 精确包含 "1234", "5678"

        // 插入事实到工作内存
        kieSession.insert(t1);
        kieSession.insert(t2);
        kieSession.insert(t3);

        // 触发所有规则
        kieSession.fireAllRules();
        kieSession.dispose();
    }
}

kmodule.xml (位于 src/main/resources/META-INF):

<?xml version="1.0" encoding="UTF-8"?>
<kmodule xmlns="http://www.drools.org/xsd/kmodule">
    <kbase name="rules" packages="com.abc">
        <ksession name="ksession-rules"/>
    </kbase>
</kmodule>

预期输出：

abc found by name-rule
Fact contains contact number 1111: abc
M1 rule-data matches fact FOUND: contains both 1234 and 5678 for xyz
M1 rule-data matches fact FOUND: contains both 1234 and 5678 for pqr
Exact match found for contactNumbers (1234, 5678) for: pqr

注意事项与最佳实践

• Drools版本： 本文示例基于Drools 8.29.0版本。不同版本在语法或MVEL表达式支持上可能略有差异，但核心概念通常保持一致。
• contains 与 memberOf 的选择：
  • collectionField contains "value"：用于检查事实的集合字段是否包含某个字面量或变量。
  • "value" memberOf collectionField：用于检查某个字面量或变量是否在事实的集合字段中。在某些情况下，两者可以互换，但contains通常更直观地表达“集合包含某物”。
• MVEL表达式： Drools的条件部分支持MVEL表达式。虽然MVEL功能强大，但在集合比较方面，建议优先使用Drools提供的内置操作符和accumulate，它们通常更优化、更具可读性。
• Oopath 风格： Drools文档也推荐使用Oopath风格（例如 /tests [contactNumbers contains "12345"]）来编写规则。这种风格在处理嵌套对象时可能更清晰，但在功能上与本文中的直接模式匹配是等效的。
• 性能考量： 对于非常大的集合或需要频繁执行的复杂accumulate规则，应考虑其性能影响。在某些情况下，预处理数据或在Java代码中进行部分复杂计算可能更高效。

总结

在Drools规则引擎中进行集合比较需要理解其内置操作符的语义。对于简单的单值包含检查，contains和memberOf是首选。当需要检查集合是否包含多个特定元素（AND逻辑）时，可以通过组合多个contains条件实现。而对于需要精确匹配集合内容、执行聚合或更复杂过滤的场景，accumulate语句提供了强大的灵活性和表达能力。掌握这些技巧，将有助于你编写出更强大、更精确的Drools规则来处理复杂的业务逻辑。

本文转载于：互联网 如有侵犯，请联系zhengruancom@outlook.com删除。
免责声明：正软商城发布此文仅为传递信息，不代表正软商城认同其观点或证实其描述。