Java自定义事件和日志记录

我有一个简单的自定义事件处理程序来处理事件并将事件传递给适当的事件处理器。例如，假设Event0触发3个其他事件（Event1、Event2、Event3）

例如，让我们假设传递的第一个事件是Event0。。。通过处理器循环检查是否所有活动处理器都对Event0感兴趣，如果感兴趣，则处理该事件

protected Event process(Event event) {
         String parId = event.getId();
        if (event instanceof Event0){
            return new EventA(EventAId(parId), parId, 0);
        }else if (event instanceof Event1){
         return new EventA(EventAId(parId), parId, 0);
        }   throw new IllegalArgumentException("unknown event  " + event);
    }

另外，假设我有其他处理器在检测到事件时触发

EventA看起来像

public class EventA implements Event {

    private final String id;
    private final String parentId;
    private final double value;

    public EventA(String id, String parentId, double value) {
        this.id = id;
        this.parentId = parentId;
        this.value= value;
    }

    public String getId() {
        return id;
    }

    public String getParentId() {
        return parentId;
    }

    public double getValue() {
        return value;
    }
}

如何将整个事件链存储在下面ChainedEvent对象内的hashmap中？--我基本上想知道应该在哪里放置ChainedEvent构造函数，以及应该在哪里调用ChainedEvent对象上的add方法？

public class ChainedEvent implements Event {

    private final String id;
    private final Event parent;
    private final Map<String, Event> children = new HashMap<>();

    public ChainedEvent(String id, Event parent) {
        this.id = id;
        this.parent = parent;
    }

    public String getId() {
        return id;
    }

    public Event getParent() {
        return parent;
    }

    public ChainedEvent addChild(Event child) {
        children.put(child.getId(), child);
        return this;
    }

    public int size() {
        return children.size();
    }

}

---

as receive（事件）从事件0多次触发。。所以输出就是我想要的。。。现在，我如何将其存储到ChainedEvent对象内的hashmap中？

我认为您的基本问题有两个：

如何确定偶数是否为“链的顶端”，并应实例化新的ChainedEvent

如果事件不是“链的顶端”，则如何查找应将其添加到的ChainedEvent

1.开始一条新的链条 第一个比较容易。我认为您需要在

Processor.process（）方法中执行此操作。如果事件是“链的顶端”，则实例化ChainedEvent对象，否则将该事件作为子事件添加。以下是您可以如何做到这一点的想法：

protected Event process(Event event) {
         String parId = event.getId();
        ChainedEvent thisEventsChain;
        if (event.getParentId() == null) //assuming parent is null for top of chain
                                         //could equally test
                                         // event.getParentId().equals("");
        {
            thisEventsChain = new ChainedEvent(parId,event)
        }

        if (event instanceof Event0){
            Event childEvent = new EventA(EventAId(parId), parId, 0);
            thisChainedEvent.addChild(childEvent);
            return childEvent;
        }else if (event instanceof Event1){
            Event childEvent = new EventA(EventAId(parId), parId, 0);
            thisChainedEvent.addChild(childEvent);
            return childEvent;
        }   throw new IllegalArgumentException("unknown event  " + event);
    }

2.为孩子找锁链
您可能需要向事件接口添加一个新方法。我推荐
getEventChain（）
。每个事件都可以存储对其所属ChainedEvent的引用，并返回该引用。事实上，这可能会为“链顶”事件返回null，从而无需像上面的1.那样测试
ParentId
。因此，在您的
处理器.process（）
中，如果您正在处理一个已经有ChainedEvent的事件，您可以向该事件添加子事件-如果它没有
ChainedEvent
，您可以实例化一个。
我需要一些澄清-我从
ChainedEvent
的设置中获取它，您只对2
Event
s长的链感兴趣？i、 e.您只想在示例中捕获
Event0
及其子级？如果是这种情况，您能否澄清为什么仅仅保持对
EventA
的引用，然后查询其
getParent（）
是不够的？两个事件“长”就是一个例子。基于处理器，它可以更长。。例如，Event0->EventA->EventC->EventDOK-明白了。我也看到了对这个问题的澄清。FWIW-这正是我一直在思考的问题-您希望构造函数在哪里。您是否始终知道“链的起点”将是一个
事件0
？或者至少在一组特定的
事件
类型中，您在
处理器
中处理这些类型？现在有四种不同的事件类型。如果类型是固定的，会更容易吗？我想写它，所以不管有多少种类型。我也很难弄清楚如何通过编程来确定链的开始。好的，我已经根据你的问题给出了答案。不过，我很好奇——我看不出你想做这件事的背景。特别是，您似乎在复制函数-您可以从
事件
对象中计算出一个链，方法是跟随
parentId
，直到得到一个空值，但是您还实现了
ChainedEvent
，它也实现了
事件
接口-它也是由事件处理器处理的吗
（即，与其中的事件分开触发？）
Recieved Event: com.x4rq.events.Event0@761b2f32
Recieved Event: com.x4rq.events.EventA@11c0f73a
Recieved Event: com.x4rq.events.EventB@13a709f1
Recieved Event: com.x4rq.events.EventC@3b7db74b

protected Event process(Event event) {
         String parId = event.getId();
        ChainedEvent thisEventsChain;
        if (event.getParentId() == null) //assuming parent is null for top of chain
                                         //could equally test
                                         // event.getParentId().equals("");
        {
            thisEventsChain = new ChainedEvent(parId,event)
        }

        if (event instanceof Event0){
            Event childEvent = new EventA(EventAId(parId), parId, 0);
            thisChainedEvent.addChild(childEvent);
            return childEvent;
        }else if (event instanceof Event1){
            Event childEvent = new EventA(EventAId(parId), parId, 0);
            thisChainedEvent.addChild(childEvent);
            return childEvent;
        }   throw new IllegalArgumentException("unknown event  " + event);
    }