做梦的时候写了个事件处理器框架

EventProcessorFk事件处理框架

引言

随着数据量的不断增长，实时处理事件的需求也变得越来越迫切。异步事件处理框架可以帮助我们高效地处理大量事件，并从中提取有价值的信息。在本文中，我们将手写一个事件处理框架。

应用场景

• 物联网数据处理：

物联网设备产生的数据量巨大，而且往往是实时产生的。传统的数据处理方法难以处理如此海量的数据。它可以帮助我们高效地处理物联网设备产生的数据，并从中提取有价值的信息。例如，我们可以使用该框架来监控物联网设备的状态、检测异常情况、并触发相应的告警。

• 日志分析：

日志数据是系统运行的重要信息来源。通过分析日志数据，我们可以发现系统中的安全威胁、性能问题等各种问题。它可以帮助我们高效地分析日志数据，并从中提取有价值的信息。例如，我们可以使用该框架来检测可疑的登录活动、识别恶意软件的攻击行为、并分析系统性能问题。

• 用户行为分析：

用户行为数据可以帮助我们了解用户的需求和偏好。通过分析用户行为数据，我们可以改进我们的产品和服务，并提供更好的用户体验。它可以帮助我们高效地分析用户行为数据，并从中提取有价值的信息。例如，我们可以使用该框架来分析用户的点击行为、购买行为、搜索行为等，并从中发现用户偏好、购买习惯等信息。

• 实时流媒体处理：

实时流媒体数据是指不断产生的数据流，例如视频流、音频流等。实时流媒体数据处理是一项非常具有挑战性的任务，因为它要求我们能够实时地处理数据流，并从中提取有价值的信息。它可以帮助我们高效地处理实时流媒体数据，并从中提取有价值的信息。例如，我们可以使用该框架来分析视频中的物体、人物等信息，并提供实时的视频分析结果。

EventProcessorFk主要功能

• 事件过滤： 此框架允许您过滤事件。您可以定义自己的过滤器来确定哪些事件应该被处理，哪些应该被丢弃。
• 事件优先级：优先级高的会被有限处理
• 事件处理： 此框架允许您处理事件。您可以定义自己的处理器来处理事件。
• 事件监控： 此框架允许您监控事件处理过程。您可以使用监控器来收集有关事件处理的指标，例如吞吐量、延迟和错误率。
• 异步处理： 此框架支持异步处理事件。这意味着您可以同时处理多个事件，从而提高吞吐量。
• 超时处理： 此框架支持超时处理。您可以为事件定义超时时间。如果事件在超时时间内没有被处理，则可以采取相应的措施，例如重新发送事件或记录错误。
• 链式回调： 此框架支持链式回调。您可以定义多个过滤器或处理器，并将其链接在一起。当事件发生时，它将按照链中的顺序被处理。
• 支持多种事件类型： 此框架支持多种事件类型。您可以定义自己的事件类型，并使用框架来处理这些事件。
• 可扩展性： 此框架是可扩展的。您可以根据需要添加新的过滤器、处理器和监控器。
• 易于使用： 此框架易于使用。您可以通过简单的 API 来定义过滤器、处理器和监控器。

总之，此框架是一个功能强大且易于使用的事件处理框架。它可以帮助您轻松地过滤、处理和监控事件。

注意到了 EnhancedAsyncEventProcessor 使用的是单线程模型来分发事件。这种模型的好处包括：

• 简单性： 单线程模型比多线程模型更简单。它更容易实现和维护。
• 可预测性： 单线程模型更具可预测性。您可以更轻松地预测事件的处理顺序。
• 避免竞争条件： 单线程模型可以避免竞争条件。当多个线程同时访问共享资源时，可能会发生竞争条件。在单线程模型中，只有一个线程可以访问共享资源，因此不会发生竞争条件。
• 更高的吞吐量： 在某些情况下，单线程模型可以提供更高的吞吐量。这是因为单线程模型可以避免线程切换的开销。

核心类

• EnhancedAsyncEventProcessor: 这是一个事件处理器，它负责处理事件。它具有可扩展性、线程安全、单线程模型到多线程可定义处理量、事件过滤、超时处理和链式回调等特点。
• Event: 这是一个事件类，它包含事件的优先级和时间戳。
• EventListener: 这是一个事件监听器接口，它定义了处理事件的方法。
• EventFilter: 这是一个事件过滤器接口，它定义了过滤事件的方法。
• Filter: 这是一个过滤器类，它实现了 EventFilter 接口。它可以过滤事件。
• Processor: 这是一个处理器接口，它定义了处理事件的方法。
• ProcessorConfig: 这是一个处理器配置类，它实现了 Processor 接口。它提供了处理器的一些基本配置。
• ProcessorTimeOutConfig: 这是一个处理器超时配置类，它继承了 ProcessorConfig 类。它提供了事件超时处理。
• CustomBoundedPriorityQueue: 这是一个自定义的有界优先级队列类。它可以管理队列中的事件。
• QueueOverflow: 这是一个队列溢出策略接口，它定义了处理队列溢出事件的方法。
• QueueOverflowSwapPriorities: 这是一个队列溢出策略类，它实现了 QueueOverflow 接口。它使用交换优先级策略来处理队列溢出。

说明：

• EnhancedAsyncEventProcessor 使用单线程模型来分发事件，而事件处理本身是异步的。这使得 EnhancedAsyncEventProcessor 能够同时处理多个事件，从而提高吞吐量。
• EnhancedAsyncEventProcessor 支持事件过滤。您可以定义自己的过滤器来确定哪些事件应该被处理，哪些应该被丢弃。
• EnhancedAsyncEventProcessor 支持超时处理。您可以为事件定义超时时间。如果事件在超时时间内没有被处理，则可以采取相应的措施，例如重新发送事件或记录错误。
• EnhancedAsyncEventProcessor 支持链式回调。您可以定义多个过滤器或处理器，并将其链接在一起。当事件发生时，它将按照链中的顺序被处理。

• EnhancedAsyncEventProcessor: 事件处理器

public class EnhancedAsyncEventProcessor {
    // 处理器
    private final Processor<Event> processor;
    // 自定义一个有序的阻塞队列
    private final CustomBoundedPriorityQueue<Event> eventQueue;

    // 使用单线程模型
    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
    // ConcurrentHashMap是HashMap的安全版，CopyOnWriteArrayList是ArrayList的安全版
    private final ConcurrentHashMap<Class<? extends Event>,
            // 使用CopyOnWriteArrayList，它是线程安全的集合，并且内部使用了一个读写锁来保证在遍历列表时，其他线程不会对列表进行修改。
            CopyOnWriteArrayList<AbstractEventListener<?>>> listenersMap;

    // AtomicBoolean是java.util.concurrent.atomic包中的一个原子布尔类型，它可以保证多个线程能够安全地访问和修改boolean值
    private final AtomicBoolean atomicBoolean = new AtomicBoolean(false);

    public EnhancedAsyncEventProcessor(int queueCapacity, Processor<Event> processor) {
        this(queueCapacity, processor, null, new QueueOverflow<>());
    }

    public EnhancedAsyncEventProcessor(int queueCapacity, Processor<Event> processor, Monitor monitor) {
        this(queueCapacity, processor, monitor, new QueueOverflow<>());
    }

    public EnhancedAsyncEventProcessor(int queueCapacity, Processor<Event> processor, Monitor monitor, QueueOverflow<Event> queueOverflow) {
        this.processor = processor;
        this.listenersMap = new ConcurrentHashMap<>();
        this.monitor = monitor;
        this.eventQueue = new CustomBoundedPriorityQueue<>(
                queueCapacity,//这里使用固定容量，如果需要动态容量功能，使用者自己扩展
                (o1, o2) -> o2.getPriority() - o1.getPriority(), //带优先级比较，优先级高的最先出对供使用处理
                queueOverflow//溢出策略
        );
    }

    public <T extends Event> void registerListener(Class<T> eventType, AbstractEventListener<T> listener) {
        //如果不存在可创建new CopyOnWriteArrayList 实例集合。存在直接添加CopyOnWriteArrayList里。
        listenersMap.computeIfAbsent(eventType, k -> new CopyOnWriteArrayList<>()).add(listener);
    }

    public <T extends Event> void removeListener(Class<T> eventType, EventListener<T> listener) {
        //如果指定的键存在，CopyOnWriteArrayList 实例集合中移除指定键值
        listenersMap.computeIfPresent(eventType, (k, v) -> {
            v.remove(listener);
            if (v.isEmpty()) {
                return null;
            }
            //可返回CopyOnWriteArrayList集合
            return v;
        });
    }

    public void setFilterAtEntry(EventEntryFilter filter) {
        this.filter = filter;
    }

    public void processEventAndFilter(Event event) {
        if (filter == null ||
                filter.accept(event)) {//filter.accept(..)返回false不会入队处理，true入队处理器开始处理
            //并发下offer和notify一起使用需要安全，加上synchronized
            synchronized (eventQueue) {
                if (monitor != null) {
                    monitor.eventEntry();
                }
                eventQueue.offer(event);//offer方法尝试添加事件到队列
                eventQueue.notify();
            }
        }
    }

    public boolean getProcessingState() {
        return atomicBoolean.get();
    }

    public void startProcessing() {
        processor.start();
        //提交任务
        executorService.submit(() -> {
            if (!atomicBoolean.get()) {
                atomicBoolean.set(true);
            }
            if (monitor != null) {
                monitor.start(true);
            }
            //这里单线程模型的事件循环
            while (atomicBoolean.get()) {
                try {
                    //执行事件循环
                    processNextEvent();
                } catch (InterruptedException e) {
                    //InterruptedException异常时，当前线程设置为中断状态。
                    Thread.currentThread().interrupt();
                    //退出事件循环
                    break;
                } catch (Exception e) {
                    if (monitor != null) {
                        monitor.processError(e);
                    }
                    //处理处理器异常，如打印信息到日志
                    handleProc