Java 流口水-如何找出所有规则都匹配？

我有一个.DRL文件，上面有10条规则。一旦我插入一个事实，一些规则可能会被匹配-我如何找出哪些规则是以编程方式匹配的

在DRL文件中将方言更改为JAVA

插入一个从java文件到DRL文件的HashMap（使用Drools会话概念）， 其中应包含规则名称作为键，布尔值作为结果

按照此操作了解如何将映射插入到DRL文件

您现在可以找到完全匹配的规则

希望这能有所帮助：）

请注意，这个答案对Drools高达5.x的版本有效。如果您已经转到6或更高级别，请查看@melchoir55的修改答案。我还没有亲自测试过，但我相信它能工作

要跟踪规则激活，可以使用AgendaEventListener。下面是一个示例，如下所示：

您只需创建这样一个侦听器并将其连接到会话，如下所示：

ksession = kbase.newStatefulKnowledgeSession();
AgendaEventListener agendaEventListener = new TrackingAgendaEventListener();
ksession.addEventListener(agendaEventListener);
//...
ksession.fireAllRules();
//...
List<Activation> activations = agendaEventListener.getActivationList();

ksession=kbase.newStatefulKnowledgeSession（）；
AgendaEventListener AgendaEventListener=new TrackingAgendaEventListener（）；
ksSession.addEventListener（代理EventListener）；
//...
ksession.fireAllRules（）；
//...
List activations=agendaEventListener.getActivationList（）；

请注意，还有WorkingMemoryEventListener，它使您能够跟踪事实的插入、更新和收回

跟踪和日志记录代理DaEventListener的代码：

package com.sctrcd.drools.util;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.drools.definition.rule.Rule;
import org.drools.event.rule.DefaultAgendaEventListener;
import org.drools.event.rule.AfterActivationFiredEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * A listener that will track all rule firings in a session.
 * 
 * @author Stephen Masters
 */
public class TrackingAgendaEventListener extends DefaultAgendaEventListener {

    private static Logger log = LoggerFactory.getLogger(TrackingAgendaEventListener.class);

    private List<Activation> activationList = new ArrayList<Activation>();

    @Override
    public void afterActivationFired(AfterActivationFiredEvent event) {
        Rule rule = event.getActivation().getRule();

        String ruleName = rule.getName();
        Map<String, Object> ruleMetaDataMap = rule.getMetaData();

        activationList.add(new Activation(ruleName));
        StringBuilder sb = new StringBuilder("Rule fired: " + ruleName);

        if (ruleMetaDataMap.size() > 0) {
            sb.append("\n  With [" + ruleMetaDataMap.size() + "] meta-data:");
            for (String key : ruleMetaDataMap.keySet()) {
                sb.append("\n    key=" + key + ", value="
                        + ruleMetaDataMap.get(key));
            }
        }

        log.debug(sb.toString());
    }

    public boolean isRuleFired(String ruleName) {
        for (Activation a : activationList) {
            if (a.getRuleName().equals(ruleName)) {
                return true;
            }
        }
        return false;
    }

    public void reset() {
        activationList.clear();
    }

    public final List<Activation> getActivationList() {
        return activationList;
    }

    public String activationsToString() {
        if (activationList.size() == 0) {
            return "No activations occurred.";
        } else {
            StringBuilder sb = new StringBuilder("Activations: ");
            for (Activation activation : activationList) {
                sb.append("\n  rule: ").append(activation.getRuleName());
            }
            return sb.toString();
        }
    }

}

package com.sctrcd.drools.util；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.Map；
导入org.drools.definition.rule.rule；
导入org.drools.event.rule.DefaultAgendaEventListener；
导入org.drools.event.rule.afterActivationFileEvent；
导入org.slf4j.Logger；
导入org.slf4j.LoggerFactory；
/**
*跟踪会话中所有规则触发的侦听器。
* 
*@作者斯蒂芬·马斯特斯
*/
公共类跟踪GendaEventListener扩展DefaultAgendaEventListener{
私有静态记录器log=LoggerFactory.getLogger（TrackingAgendaEventListener.class）；
私有列表激活列表=新建ArrayList（）；
@凌驾
公共无效后激活事件（后激活事件）{
规则规则=event.getActivation（）.getRule（）；
字符串ruleName=rule.getName（）；
Map ruleMetaDataMap=rule.getMetaData（）；
activationList.add（新激活（规则名））；
StringBuilder sb=新的StringBuilder（“触发规则：+ruleName”）；
if（ruleMetaDataMap.size（）>0）{
sb.追加（“\n带有[”+ruleMetaDataMap.size（）+“]元数据：”）；
for（字符串键：ruleMetaDataMap.keySet（））{
sb.追加（“\n key=“+key+”，value=”
+ruleMetaDataMap.get（key））；
}
}
log.debug（sb.toString（））；
}
公共布尔值isRuleFired（字符串ruleName）{
用于（激活a：激活列表）{
如果（a.getRuleName（）.equals（ruleName））{
返回true；
}
}
返回false；
}
公共无效重置（）{
activationList.clear（）；
}
公共最终列表getActivationList（）{
返回激活列表；
}
公共字符串激活ToString（）{
if（activationList.size（）=0）{
return“未发生任何激活。”；
}否则{
StringBuilder sb=新StringBuilder（“激活：”）；
用于（激活：激活列表）{
sb.append（“\n规则：”）.append（activation.getRuleName（））；
}
使某人返回字符串（）；
}
}
}

您可以使用静态记录器工厂，该工厂将使用您喜爱的记录器记录DRL文件中的操作

例如：

import org.drools.runtime.rule.RuleContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public final class DRLLogger {

private DRLLogger() {
}

protected static Logger getLogger(final RuleContext drools) {
    final String category = drools.getRule().getPackageName() + "." + drools.getRule().getName();
    final Logger logger = LoggerFactory.getLogger(category);
    return logger;
}

public static void info(final RuleContext drools, final String message, final Object... parameters) {
    final Logger logger = getLogger(drools);
    logger.info(message, parameters);
}

public static void debug(final RuleContext drools, final String message, final Object... parameters) {
    final Logger logger = getLogger(drools);
    logger.debug(message, parameters);
}

public static void error(final RuleContext drools, final String message, final Object... parameters) {
    final Logger logger = getLogger(drools);
    logger.error(message, parameters);
}

}

然后从您的DRL文件：

import function com.mycompany.DRLLogger.*

rule "myrule"
when
    $fact: Fact()
then
    info(drools, "Fact:{}", $fact);
end

---

Steve的答案是肯定的，但drools 6带来的主要变化使代码过时。我在下面发布了Steve代码的重写，其中考虑了新api：

package your.preferred.package;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.drools.core.event.DefaultAgendaEventListener;
import org.kie.api.definition.rule.Rule;
import org.kie.api.event.rule.AfterMatchFiredEvent;
import org.kie.api.runtime.rule.Match;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * A listener that will track all rule firings in a session.
 * 
 * @author Stephen Masters, Isaac Martin
 */
public class TrackingAgendaEventListener extends DefaultAgendaEventListener  {

    private static Logger log = LoggerFactory.getLogger(TrackingAgendaEventListener.class);

    private List<Match> matchList = new ArrayList<Match>();

    @Override
    public void afterMatchFired(AfterMatchFiredEvent event) {
        Rule rule = event.getMatch().getRule();

        String ruleName = rule.getName();
        Map<String, Object> ruleMetaDataMap = rule.getMetaData();

        matchList.add(event.getMatch());
        StringBuilder sb = new StringBuilder("Rule fired: " + ruleName);

        if (ruleMetaDataMap.size() > 0) {
            sb.append("\n  With [" + ruleMetaDataMap.size() + "] meta-data:");
            for (String key : ruleMetaDataMap.keySet()) {
                sb.append("\n    key=" + key + ", value="
                        + ruleMetaDataMap.get(key));
            }
        }

        log.debug(sb.toString());
    }

    public boolean isRuleFired(String ruleName) {
        for (Match a : matchList) {
            if (a.getRule().getName().equals(ruleName)) {
                return true;
            }
        }
        return false;
    }

    public void reset() {
        matchList.clear();
    }

    public final List<Match> getMatchList() {
        return matchList;
    }

    public String matchsToString() {
        if (matchList.size() == 0) {
            return "No matchs occurred.";
        } else {
            StringBuilder sb = new StringBuilder("Matchs: ");
            for (Match match : matchList) {
                sb.append("\n  rule: ").append(match.getRule().getName());
            }
            return sb.toString();
        }
    }

}

打包您的.preferred.package；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.Map；
导入org.drools.core.event.DefaultAgendaEventListener；
导入org.kie.api.definition.rule.rule；
导入org.kie.api.event.rule.AfterMatchFiredEvent；
导入org.kie.api.runtime.rule.Match；
导入org.slf4j.Logger；
导入org.slf4j.LoggerFactory；
/**
*跟踪会话中所有规则触发的侦听器。
* 
*@作者斯蒂芬·马斯特斯，艾萨克·马丁
*/
公共类跟踪GendaEventListener扩展DefaultAgendaEventListener{
私有静态记录器log=LoggerFactory.getLogger（TrackingAgendaEventListener.class）；
私有列表匹配列表=新的ArrayList（）；
@凌驾
公共无效afterMatchFired（AfterMatchFiredEvent事件）{
Rule Rule=event.getMatch（）.getRule（）；
字符串ruleName=rule.getName（）；
Map ruleMetaDataMap=rule.getMetaData（）；
add（event.getMatch（））；
StringBuilder sb=新的StringBuilder（“触发规则：+ruleName”）；
if（ruleMetaDataMap.size（）>0）{
sb.追加（“\n带有[”+ruleMetaDataMap.size（）+“]元数据：”）；
for（字符串键：ruleMetaDataMap.keySet（））{
sb.追加（“\n key=“+key+”，value=”
+ruleMetaDataMap.get（key））；
}
}
log.debug（sb.toString（））；
}
公共布尔值isRuleFired（字符串ruleName）{
用于（匹配a：匹配列表）{
如果（a.getRule（）.getName（）.equals（ruleName））{
返回true；
}
}
返回false；
}
公共无效重置（）{
matchList.clear（）；
}
公共最终列表getMatchList（）{
返回匹配列表；
}
公共字符串匹配stostring（）{
if（matchList.size（）==0）{
return“未发生匹配。”；
}否则{
StringBuilder sb=新的StringBuilder（“匹配：”）；
用于（匹配：匹配列表）{
sb.append（“\n规则：”）.append
System.out.println(drools.getRule().getName())