追溯模式以及如何替换事件答案

【问题标题】：Retroactive pattern and how events are replaced追溯模式以及如何替换事件
【发布时间】：2018-06-06 10:37:35
【问题描述】：

我正在尝试编写一个使用 Martin Fowler 描述的事件溯源和追溯模式的工作代码。

我对事件如何排队有点迷茫？因为事件被一一发送到 EventProcessor 的 process 和 reverse 函数。他在他的文章中说 EventProcessor 类将有权访问事件队列。

但如果我/他的 EventProcessor 类看起来像这样

public class DomainEventProcessor {

    public void process(DomainEvent domainEvent) {

        if (domainEvent instanceof ReplacementEvent) {
            processReplacement((ReplacementEvent)domainEvent);
        } else {
            domainEvent.process();
        }
    }

    public void reverse(DomainEvent domainEvent) {
        domainEvent.reverse();
    }

    /*
    // replace the  event in event queue
     */
    private void processReplacement(ReplacementEvent e) {


    }
}

领域事件接口

public abstract class DomainEvent implements Serializable {

    public abstract void process();

    public abstract void reverse();
}

示例实现事件如下所示

public class BalanceUpdateEvent extends DomainEvent {

    private String subscriberId;

    private String balanceId;

    private Long delta;

    public String getSubscriberId() {
        return subscriberId;
    }

    public String getBalanceId() {
        return balanceId;
    }

    public Long getDelta() {
        return delta;
    }

    @Override
    public void process() {
    // do nothing
    }

    @Override
    public void reverse() {
        SubscriberDomain subscriberDomain = SubscriberAggregate.getSubscriber(subscriberId);
        subscriberDomain.handleReverseEvent(this);
    }
}

每个事件都知道哪个域对象（具有状态 + 业务逻辑）可以自行处理以更改域对象状态。

【问题讨论】：

标签： java events design-patterns event-handling

【解决方案1】：

public class DomainEventProcessor {

    private EventStore es;

    public DomainEventProcessor(EventStore es) {
        this.es = es;
    }

    public void replay(String aggregateId,Date after) {
        List<DomainEvent> events = es.loadEventStreamAfter(aggregateId,after);
        events.sort(Comparator.comparing(DomainEvent::getTimestamp));
        for(DomainEvent event : events) {
            if (event instanceof ReplacementEvent) {
                ReplacementEvent re = (ReplacementEvent)event;
                re.getReplacement().process();
            } else {
                event.process();
            }
        }
    }

    public void reverse(String aggregateId,Date after) {
        List<DomainEvent> events = es.loadEventStreamAfter(aggregateId,after);
        events.sort(Comparator.comparing(DomainEvent::getTimestamp).reversed());
        for(DomainEvent event : events) {
            if (event instanceof ReplacementEvent) {
                ReplacementEvent re = (ReplacementEvent)event;
                re.getOriginal().reverse();
            } else {
                event.reverse();
            }
        }
    }
}

【讨论】：