public void updateConditions(String expiration, Collection<FullTrigger> activeTriggers) {
    expression = new Expression(expiration, activeTriggers);
    log.debugf("Rules: \n  %s", expression);
    stop();
    KieBaseConfiguration kieBaseConfiguration = KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
    kieBaseConfiguration.setOption( EventProcessingOption.STREAM );
    KieBase kieBase = new KieHelper().addContent(expression.getDrl(), ResourceType.DRL).build(kieBaseConfiguration);
    KieSessionConfiguration kieSessionConf = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();
    kieSessionConf.setOption( ClockTypeOption.get( "realtime" ) );

    kieSession = kieBase.newKieSession(kieSessionConf, null);
    results = new ArrayList<>();
    kieSession.setGlobal("results", this);
    kieSession.setGlobal("log", log);
    if (log.isDebugEnabled()) {
        kieSession.addEventListener(new CepAgendaEventListener());
        kieSession.addEventListener(new CepRuleRuntimeEventListener());
    }
    log.debugf("Clock time [%s] ", kieSession.getSessionClock().getCurrentTime());

    kieSession.getKieBase().getKiePackages().stream().forEach(p -> log.debugf("Rules: %s", p.getRules()));

    executor.submit(() -> {
        log.info("Starting fireUntilHalt()");
        kieSession.fireUntilHalt();
        log.info("Stopping fireUntilHalt()");
    });
}
 

private void startSession(String drl) {
    kieBaseConfiguration = KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
    kieBaseConfiguration.setOption( EventProcessingOption.STREAM );
    kieBase = new KieHelper().addContent(drl, ResourceType.DRL).build(kieBaseConfiguration);
    kieSessionConf = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();
    kieSessionConf.setOption( ClockTypeOption.get( "pseudo" ) );
    kieSession = kieBase.newKieSession(kieSessionConf, null);
    clock = kieSession.getSessionClock();
    // kieSession.addEventListener(new DebugAgendaEventListener());
    // kieSession.addEventListener(new DebugRuleRuntimeEventListener());
    results = new ArrayList<>();
    kieSession.setGlobal("clock", clock);
    kieSession.setGlobal("results", new CepEngine() {
        @Override
        public void sendResult(Event event) {
            results.add(event);
        }

        @Override
        public void updateConditions(String expiration, Collection<FullTrigger> activeTriggers) { }

        @Override
        public void processEvents(TreeSet<Event> events) { }

        @Override
        public void stop() { }
    });
}
 

private void startSession(String drl) {
    kieBaseConfiguration = KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
    kieBaseConfiguration.setOption( EventProcessingOption.STREAM );
    kieBase = new KieHelper().addContent(drl, ResourceType.DRL).build(kieBaseConfiguration);
    kieSessionConf = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();
    kieSessionConf.setOption( ClockTypeOption.get( "pseudo" ) );
    kieSession = kieBase.newKieSession(kieSessionConf, null);
    clock = kieSession.getSessionClock();
    // kieSession.addEventListener(new DebugAgendaEventListener());
    // kieSession.addEventListener(new DebugRuleRuntimeEventListener());
    results = new ArrayList<>();
    kieSession.setGlobal("clock", clock);
    kieSession.setGlobal("results", results);
}
 

public static void main(String[] args) {
	//rule,rule2可以放在数据库中，有个唯一code和他们对于，代码要执行规则的时候，根据code从数据库获取出来就OK了，这样自己开发的规则管理系统那边对数据库里的规则进行维护就行了
	String rule = "package com.neo.drools\r\n";
	rule += "import com.neo.drools.model.Message;\r\n";
	rule += "rule \"rule1\"\r\n";
	rule += "\twhen\r\n";
	rule += "Message( status == 1, myMessage : msg )";
	rule += "\tthen\r\n";
	rule += "\t\tSystem.out.println( 1+\":\"+myMessage );\r\n";
	rule += "end\r\n";


	String rule2 = "package com.neo.drools\r\n";
	rule += "import com.neo.drools.model.Message;\r\n";

	rule += "rule \"rule2\"\r\n";
	rule += "\twhen\r\n";
	rule += "Message( status == 2, myMessage : msg )";
	rule += "\tthen\r\n";
	rule += "\t\tSystem.out.println( 2+\":\"+myMessage );\r\n";
	rule += "end\r\n";


	StatefulKnowledgeSession kSession = null;
	try {


		KnowledgeBuilder kb = KnowledgeBuilderFactory.newKnowledgeBuilder();
		//装入规则，可以装入多个
		kb.add(ResourceFactory.newByteArrayResource(rule.getBytes("utf-8")), ResourceType.DRL);
		kb.add(ResourceFactory.newByteArrayResource(rule2.getBytes("utf-8")), ResourceType.DRL);

		KnowledgeBuilderErrors errors = kb.getErrors();
		for (KnowledgeBuilderError error : errors) {
			System.out.println(error);
		}
		KnowledgeBase kBase = KnowledgeBaseFactory.newKnowledgeBase();
		kBase.addKnowledgePackages(kb.getKnowledgePackages());

		kSession = kBase.newStatefulKnowledgeSession();


		Message message1 = new Message();
		message1.setStatus(1);
		message1.setMsg("hello world!");

		Message message2 = new Message();
		message2.setStatus(2);
		message2.setMsg("hi world!");

		kSession.insert(message1);
		kSession.insert(message2);
		kSession.fireAllRules();

	} catch (UnsupportedEncodingException e) {
		e.printStackTrace();
	} finally {
		if (kSession != null)
			kSession.dispose();
	}

}
 

public static KieSession buildKieSession(KieBase kieBase) {
    KieSessionConfiguration sessionConf = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();
    sessionConf.setOption(ClockTypeOption.get(ClockType.PSEUDO_CLOCK.getId()));
    KieSession session = kieBase.newKieSession(sessionConf, null);
    return session;
}