Question

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

public void receive(Event event) {
        synchronized(this){
            this.event = event;
        for(Processor processor : processors){
            if(processor.interestedIn(event)){
                processor.process(this.event);
            }
        }System.out.println("Received Event: " + event);

        }
    }

例如，让我们假设传递的第一个事件是Event0 ...循环处理器以检查所有活动的处理器是否对Event0感兴趣，如果是，则它们处理事件。 / p>

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时会触发其他处理器。

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

}

父将是第一个触发的事件，子节点将是处理父节点时触发的后续事件。

System.out.println（＆＃34;收到的事件：＆＃34; +事件）; out会在发送Event0时发出以下信息：

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

as event（事件事件）从Event0多次触发..所以输出就是我想要的...现在如何将它存储到ChainedEvent对象内的hashmap中？

Answer 1

我认为你的根本问题是双重的：

如何确定偶数是否是＆＃34;链的顶部＆＃34;并且应该实例化一个新的ChainedEvent。
如果事件不是＆＃34;链的顶部＆＃34;如何找到应添加它的ChainedEvent。

1。开始新的链

第一个更容易。我认为您需要在Processor.process()方法中执行此操作。如果一个事件是＆＃34;链的顶部＆＃34;然后实例化一个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。查找儿童链

您可能需要在Event界面中添加新方法。我推荐getEventChain()。每个事件都可以存储对它所属的ChainedEvent的引用并返回它。实际上，这可能会为＆＃34;链顶部＆＃34;返回null。事件 - 无需像上面的 1。那样测试ParentId。因此，在Processor.process()中，如果您正在处理已经有ChainedEvent的事件，那么您可以添加子项 - 如果它没有ChainedEvent，则您实例化一个

Java自定义事件和日志记录

1 个答案:

1。开始新的链

2。查找儿童链