基于java8的事件驱动分发机制的实现

        事件分发机制，就好比部门领导给下属分活，不同的活可以分配给不同的人去做，领导分活这个过程不占用时间，所有公司boss所有的事情都扔给部门领导就行了。boss不需要关心是谁干了活。

        以上是一些简单的描述，懂了就懂了。下面说一下事件分发机制和消息机制的一点点区别，事件驱动就是来了就派给指定的人，消息机制就是部门领导不停回去问有那些消息或者事件需要处理，或者是pull和push的区别。

      消息机制需要一个消息循环队列不停地遍历，当出现消息选择不处理或者选择相应的处理方式，最典型的就是键盘消息，使用switch+callback模式。

    下面进入正题，要实现事件分发机制的步骤。

1.创建一个事件引擎，可以注册事件的类型，以及处理该事件类型的handler。

2.需要一个事件队列，存放事件源。

3.需要实现事件发布的接口。

4.编写至少一种事件处理handler。

java代码实现：

1.事件引擎

public abstract class AbstractEventEngine {
    protected final Logger logger = LoggerFactory.getLogger(getClass());
    protected Map>>> listeners;

    public AbstractEventEngine() {
        listeners = new HashMap>>>();
    }
    private void add(Event event, EventHandler listener, boolean isPrepend) {
        Pair> pair = new Pair>(event, listener);
        if (listeners.get(event.getType()) != null) {
            if (isPrepend == true) {
                listeners.get(event.getType()).addFirst(pair);
            } else {
                listeners.get(event.getType()).addLast(pair);
            }
        } else {
            LinkedList>> list = new LinkedList>>();
            list.add(pair);
            listeners.put(event.getType(), list);
        }
    }

    public void addListener(Event event, EventHandler listener) {
        add(event, listener, false);
    }
 
     //@param event 事件发布后，侦听者直接处理
    public abstract void publishEvent(Event event);

    protected boolean doPublishEvent(Event event) {

        Event baseEvent = new Event(event.getType());

        LinkedList>> list = listeners.get(event.getType());
        if (null != list) {
            int iListSize = list.size();
            Pair> pair = null;
            Event listenEvent = null;
            Event copyEvent = null;
            EventHandler handler = null;
            for (int index = 0; index < iListSize; index++) {
                pair = list.get(index);
                listenEvent = pair.fst;
                copyEvent = listenEvent.clone();
                handler = pair.snd;

                if (copyEvent.equals(baseEvent)) {
                    boolean ret = true;
                    try {
                        ret = handler.handle(event);
                    } catch (Exception e) {
                        publishEvent(event);
                    }
                    if (!ret) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

2.事件函数接口,

@FunctionalInterface
public interface EventHandler {
    R handle(T event);
}

3.事件handler

public abstract class RiskMoudle extends AbstractMoudle {

    public void register(AbstractEventEngine engine) {
        engine.addListener(EventType.ORDER_PENDING_NEW, this::risk);
    }

    public Boolean risk(Event event) {
        //        long s = System.nanoTime();
        RoleEvent orderEvent = Utils.cast(event);
        OrderTodayRoleInterface orderTodayRole = orderEvent.getRole();

        return doRiskCheck(orderTodayRole);
    }

    public abstract Boolean doRiskCheck(OrderTodayRoleInterface orderTodayRole);
}

说明，因为java不存在指针，所以2事件函数接口起一个函数指针的作用.在c++中用实现上述功能只需要1和3就行。