메뉴 건너뛰기

검색창 닫기

Cloudera, BigData, Semantic IoT, Hadoop, NoSQL

Cloudera CDH/CDP 및 Hadoop EcoSystem, Semantic IoT등의 개발/운영 기술을 정리합니다. gooper@gooper.com로 문의 주세요.


Drools 룰에 매칭되면 발생되는 엑티베이션 객체에 대한 작업(이전값 혹은 현재값)을 처리하는 클래스 파일

총관리자 2016.07.21 17:48 조회 수 : 377

----------------CustomAgendaEventListener.java -------------------------------
package com.gooper.drool_test;

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

import org.drools.core.event.ActivationCancelledEvent;
import org.drools.core.event.ActivationCreatedEvent;
import org.drools.core.event.AfterActivationFiredEvent;
import org.drools.core.event.BeforeActivationFiredEvent;
import org.kie.api.event.rule.AfterMatchFiredEvent;
import org.kie.api.event.rule.AgendaEventListener;
import org.kie.api.event.rule.AgendaGroupPoppedEvent;
import org.kie.api.event.rule.AgendaGroupPushedEvent;
import org.kie.api.event.rule.BeforeMatchFiredEvent;
import org.kie.api.event.rule.MatchCancelledEvent;
import org.kie.api.event.rule.MatchCreatedEvent;
import org.kie.api.event.rule.RuleFlowGroupActivatedEvent;
import org.kie.api.event.rule.RuleFlowGroupDeactivatedEvent;
import org.kie.api.runtime.rule.Match;
import org.kie.api.definition.rule.Rule;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/*
 * 룰에 매칭되면 발생되는 엑티베이션 객체에 대한 작업(이전값 혹은 현재값)
 */
public class CustomAgendaEventListener implements AgendaEventListener {
private static final Logger logger = LoggerFactory.getLogger(CustomAgendaEventListener.class);
private List<Match> matchList = new ArrayList<Match>();

// drools 5.x버젼에 존재하던 메서드
/*
public void activationCancelled(ActivationCancelledEvent event) {
logger.info("activation Cancelled : "+event.getActivation());
}
public void activationCreated(ActivationCreatedEvent event) {
logger.info("Activation Created: "+event.getActivation());
}
public void beforeActivationFired(BeforeActivationFiredEvent  event) {
logger.info("Before Activation fired: "+event.getActivation());
}

public void afterActivationFired(AfterActivationFiredEvent  event) {
logger.info("After Activation fired: "+event.getActivation());
}
*/
@Override
public void agendaGroupPopped(AgendaGroupPoppedEvent  event) {
logger.info("Agenda Group Popped: "+event.getAgendaGroup());
}

@Override
public void agendaGroupPushed(AgendaGroupPushedEvent  event) {
logger.info("Agenda Group Pushed: "+event.getAgendaGroup());
}

@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));
           }
       }

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

@Override
public void afterRuleFlowGroupActivated(RuleFlowGroupActivatedEvent event) {
logger.info("getRuleFlowGroup : "+event.getRuleFlowGroup());
}
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();
        }
    }


@Override
public void afterRuleFlowGroupDeactivated(RuleFlowGroupDeactivatedEvent event) {
logger.info("RuleFlowGroup Deactivated : "+event.getRuleFlowGroup());
}

@Override
public void beforeMatchFired(BeforeMatchFiredEvent event) {
logger.info("Before Match Fired : "+event.getMatch());
}

@Override
public void beforeRuleFlowGroupActivated(RuleFlowGroupActivatedEvent event) {
logger.info("Before RuleFlowGroup Activated  : "+event.getRuleFlowGroup());
}

@Override
public void beforeRuleFlowGroupDeactivated(RuleFlowGroupDeactivatedEvent event) {
logger.info("Before RuleFlowGroup Deactivated  : "+event.getRuleFlowGroup());
}

@Override
public void matchCancelled(MatchCancelledEvent event) {
logger.info("Match Cancelled  : "+event.getMatch());
}

@Override
public void matchCreated(MatchCreatedEvent event) {
logger.info("Match Created : "+event.getMatch());
}

}

이 게시물을
이 글의 추천인 목록 목록
쓰기 태그
위로