Java 在Drools 6.5.0和Drools 7.0.0中序列化后，临时运算符失败

我正在尝试在drools中实现序列化。我的问题是，在…之后，之前，融合算子会流口水，。。。未按预期进行序列化

如果不使用序列化和反序列化，我的规则将正常工作

我安装了一台复制机。谁能告诉我是什么问题吗。我希望规则只会触发一次。它应该在03:06:00发射一次，但它发射3次，3:04:00发射一次，3:06:00发射两次

序列化的事件：

package com.reproducer;

import java.io.Serializable;
import java.util.Date;

import org.apache.commons.lang3.builder.ToStringBuilder;

public class EventA implements Serializable {

/**
 * 
 */
private static final long serialVersionUID = 8129243856721618942L;
private int value;
private Date timestamp;

public EventA(Date timestamp, int value) {
    this.value = value;
    this.timestamp = timestamp;
}

public Date getTimestamp() {
    return timestamp;
}

public int getValue() {
    return value;
}

@Override
public String toString() {
        return new ToStringBuilder(this)
                .append("value", this.value)
                .append("timestamp", this.getTimestamp()).toString();
    }
}

测试：

@RunWith（SpringJUnit4ClassRunner.class）
@ContextConfiguration（loader=AnnotationConfigContextLoader.class）
公共类复制器{
//模拟数据和测试的数据格式化程序
专用静态DateFormat dateFormatter=新的SimpleDateFormat（“yyyy-MM-dd HH:MM:ss”）；
@配置
静态类上下文配置{
}
私人KieBase KieBase；
私人静态会话；
专用静态会话伪时钟；
私有会话配置会话配置；
公共字节[]序列化数据会话；
@试验
公共无效规则测试（）{
列表事件=getSimulationEvents（）；
startKnowledgeSession（events.get（0.getTimestamp（），false）；
运行模拟（事件）；
}
私有静态日期解析日期（字符串输入）{
日期d=空；
试一试{
d=dateFormatter.parse（输入）；
}捕获（解析异常）{
e、 printStackTrace（）；
}
返回d；
}
私有void运行模拟（列出事件）{
对于（事件A当前：事件）{
KieSession ksession2=kieBase.newKieSession（sessionConfig，null）；
Marshaller-Marshaller=KieServices.Factory.get（）.getMarshallers（）.newMarshaller（kieBase）；
试一试{
ByteArrayInputStream bais=新的ByteArrayInputStream（序列化会话）；
ksession2=marshaller.unmarshall（BAI，sessionConfig，null）；
clock=ksession2.getSessionLock（）；
bais.close（）；
}catch（classnotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
long currTime=clock.getCurrentTime（）；
long nextTime=current.getTimestamp（）.getTime（）；
while（currTime 0）{
时钟提前时间（差，时间单位毫秒）；
}
第2段插入（当前）；
ksession 2.fireAllRules（）；
//序列化知识会话
试一试{
最终ByteArrayOutputStream bas=新ByteArrayOutputStream（）；
marshaller.marshall（宝钢股份有限公司，第二届）；
serializedSession=baos.toByteArray（）；
}捕获（IOE2异常）{
e2.printStackTrace（）；
}
ksession 2.halt（）；
ksession 2.dispose（）；
}
}
私有列表getSimulationEvents（）{
列表事件=新建ArrayList（）；
添加（新事件a（解析日期（“2010-01-01 02:00:00”），0））；
添加（新事件a（解析日期（“2010-01-01 03:00:00”），1）；
添加（新事件a（解析日期（“2010-01-01 03:01:00”），0）；
添加（新事件a（解析日期（“2010-01-01 03:02:00”），1）；
添加（新事件a（解析日期（“2010-01-01 03:03:00”），0）；
添加（新事件a（解析日期（“2010-01-01 03:04:00”），0）；
添加（新事件a（解析日期（“2010-01-01 03:05:00”），0）；
添加（新事件a（解析日期（“2010-01-01 03:06:00”），0）；
添加（新事件a（解析日期（“2010-01-01 03:07:00”），0）；
返回事件；
}
private void startKnowledgeSession（日期开始时间，布尔值为节假日）{
//创建配置
StringBuffer drlR1=新的StringBuffer（）；
drlR1.append（“包测试”）；
drlR1.追加（“方言\“mvel\”\n”）；
drlR1.append（“导入com.reproducter.EventA\n”）；
追加（“import java.util.Date\n”）；
drlR1.append（“declare EventA\n”）；
drlR1.append（“@role（event）\n”）；
drlR1.append（“@timestamp（timestamp）\n”）；
drlR1.append（“end\n”）；
drlR1.append（“规则测试”）；
drlR1.append（“when\n”）；
追加（“$event:EventA（getValue（）==1）\n”）；
追加（“not（EventA（getValue（）==1，this after[1ms，4m]$event））\n”）；
drlR1.append（“then\n”）；
drlR1.append(
“System.out.println（\“Fired\”+新日期（drools.getWorkingMemory（）.getSessionLock（）.getCurrentTime（））；\n”）；
drlR1.append（“end\n”）；
kieBase=new kieheloper（）.addContent（drlR1.toString（），ResourceType.DRL）.build（EventProcessingOption.STREAM）；
sessionConfig=KnowledgeBaseFactory.newKnowledgeSessionConfiguration（）；
sessionConfig.setOption（ClockTypeOption.get（ClockType.PSEUDO_CLOCK.getId（））；
sessionConfig.setOption（TimedRuleExecutionOption.YES）；
sessionConfig.setOption（TimerJobFactoryOption.get（“可跟踪”）；
sessionConfig.setOption（ClockTypeOption.get（“伪”））；
ksession=kieBase.newKieSession（sessionConfig，null）；
//设置时钟基准
clock=ksession.getSessionLock（）；
clock.advanceTime（startTime.getTime（），TimeUnit.ms）；
sessionConfig=ksession.getSessionConfiguration（）；
//序列化知识会话
试一试{
Marshaller-Marshaller=KieServices.Factory.get（）.getMarshallers（）.newMarshaller（kieBase）；
ByteArrayOutputStream bas=新的ByteArrayOutputStream（）；
marshaller.marshall（美国陆军部，陆军部）；
serializedSession=baos.toByteArray（）；
}捕获（IOE2异常）{
e2.printStackTrace（）；
}
}
}

我在JBOSS开发人员Jira处打开了一份关于这个问题的bug报告。这是drools核心引擎中的一个bug。它将使用7.2.0最终版进行修复

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(loader = AnnotationConfigContextLoader.class)
public class Reproducer {
    // date formatter for simulation data and tests
    private static DateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Configuration
    static class ContextConfiguration {

    }

    private KieBase kieBase;
    private static KieSession ksession;
    private static SessionPseudoClock clock;
    private KieSessionConfiguration sessionConfig;

    public byte[] serializedSession;

    @Test
    public void ruleTest() {
        List<EventA> events = getSimulationEvents();
        startKnowledgeSession(events.get(0).getTimestamp(), false);
        runSimulation(events);
    }

    private static Date parseDate(String input) {
        Date d = null;
        try {
            d = dateFormatter.parse(input);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return d;
    }

    private void runSimulation(List<EventA> events) {

        for (EventA current : events) {

            KieSession ksession2 = kieBase.newKieSession(sessionConfig, null);

            Marshaller marshaller = KieServices.Factory.get().getMarshallers().newMarshaller(kieBase);

            try {
                ByteArrayInputStream bais = new ByteArrayInputStream(serializedSession);
                ksession2 = marshaller.unmarshall(bais, sessionConfig, null);
                clock = ksession2.getSessionClock();
                bais.close();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

            long currTime = clock.getCurrentTime();
            long nextTime = current.getTimestamp().getTime();

            while (currTime <= (nextTime - 1000)) {
                clock.advanceTime(1000, TimeUnit.MILLISECONDS);
                ksession2.fireAllRules();
                currTime += 1000;
            }

            long diff = nextTime - currTime;
            if (diff > 0) {
                clock.advanceTime(diff, TimeUnit.MILLISECONDS);
            }

            ksession2.insert(current);
            ksession2.fireAllRules();

            // serialize knowledge session
            try {
                final ByteArrayOutputStream baos = new ByteArrayOutputStream();
                marshaller.marshall(baos, ksession2);
                serializedSession = baos.toByteArray();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
            ksession2.halt();
            ksession2.dispose();
        }
    }

    private List<EventA> getSimulationEvents() {
        List<EventA> events = new ArrayList<EventA>();

        events.add(new EventA(parseDate("2010-01-01 02:00:00"), 0));
        events.add(new EventA(parseDate("2010-01-01 03:00:00"), 1));
        events.add(new EventA(parseDate("2010-01-01 03:01:00"), 0));
        events.add(new EventA(parseDate("2010-01-01 03:02:00"), 1));
        events.add(new EventA(parseDate("2010-01-01 03:03:00"), 0));
        events.add(new EventA(parseDate("2010-01-01 03:04:00"), 0));
        events.add(new EventA(parseDate("2010-01-01 03:05:00"), 0));
        events.add(new EventA(parseDate("2010-01-01 03:06:00"), 0));
        events.add(new EventA(parseDate("2010-01-01 03:07:00"), 0));

        return events;
    }

    private void startKnowledgeSession(Date startTime, boolean onHolidays) {
        // create configuration

        StringBuffer drlR1 = new StringBuffer();
        drlR1.append("package test\n");
        drlR1.append("dialect \"mvel\"\n");
        drlR1.append("import com.reproducer.EventA\n");
        drlR1.append("import java.util.Date\n");
        drlR1.append("declare EventA\n");
        drlR1.append("  @role(event)\n");
        drlR1.append("  @timestamp(timestamp)\n");
        drlR1.append("end\n");
        drlR1.append("rule test\n");
        drlR1.append(" when\n");
        drlR1.append("      $event : EventA(getValue() == 1)\n");
        drlR1.append("    not(EventA(getValue() == 1, this after [1ms,4m] $event))\n");
        drlR1.append(" then\n");
        drlR1.append(
                "       System.out.println(\"Fired \"+ new Date(drools.getWorkingMemory().getSessionClock().getCurrentTime()));\n");
        drlR1.append("end\n");

        kieBase = new KieHelper().addContent(drlR1.toString(), ResourceType.DRL).build(EventProcessingOption.STREAM);

        sessionConfig = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();
        sessionConfig.setOption(ClockTypeOption.get(ClockType.PSEUDO_CLOCK.getId()));
        sessionConfig.setOption(TimedRuleExecutionOption.YES);
        sessionConfig.setOption(TimerJobFactoryOption.get("trackable"));
        sessionConfig.setOption(ClockTypeOption.get("pseudo"));

        ksession = kieBase.newKieSession(sessionConfig, null);

        // set clock reference
        clock = ksession.getSessionClock();
        clock.advanceTime(startTime.getTime(), TimeUnit.MILLISECONDS);

        sessionConfig = ksession.getSessionConfiguration();
        // serialize knowledge session
        try {
            Marshaller marshaller = KieServices.Factory.get().getMarshallers().newMarshaller(kieBase);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            marshaller.marshall(baos, ksession);

            serializedSession = baos.toByteArray();
        } catch (IOException e2) {
            e2.printStackTrace();
        }
    }
}