Java 设计模式 | 事件驱动

1. 事件驱动设计模式简介

 事件驱动是一种软件架构模式，其中程序的流程是由外部事件触发的，而不是由程序内部的控制流决定。这种模式非常适合处理用户交互、异步消息处理等场景。

1. 基本组成部分

事件驱动模式主要由以下几个部分组成：
事件源：产生事件的对象。
事件：具体发生的动作或状态变化。
事件监听器：负责响应事件的对象。
事件处理器：处理事件的方法或函数。

3.  工作原理

事件注册：事件监听器注册到事件源上。
事件触发：当特定事件发生时，事件源会通知所有注册的监听器。
事件处理：监听器接收到事件后，执行相应的处理逻辑。

4.  Java 实现示例

package com.mgiot.application.EventEmitterCore;

public interface Callback {
}

package com.mgiot.application.EventEmitterCore;

@FunctionalInterface
public interface ArgsCallback extends Callback{

    void invoke(Object[] args);
}

package com.mgiot.application.EventEmitterCore;

@FunctionalInterface
public interface NoArgsCallback extends Callback{

    void invoke();
}

package com.mgiot.application.EventEmitterCore;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @program: device-platform
 * @description:
 * @author: 
 * @create: 2024-08-26 08:48
 **/
public class EventEmitter {

    private final Map<String, List<Callback>> eventBus = new HashMap<>();

    public EventEmitter emit(String eventName, Object ...args) {
        if(!checkEmitter(eventName)) {
            return this;
        }

        List<Callback> callbackList = eventBus.get(eventName);

        if(callbackList.isEmpty()) {
            return this;
        }

        callbackList.forEach(callback -> {
            if(callback instanceof ArgsCallback argsCallback) {
                argsCallback.invoke(args);
                return;
            }
            ((NoArgsCallback)callback).invoke();
        });

        return this;
    }

    private boolean checkEmitter(String eventName) {
        if (!eventBus.containsKey(eventName)) {
            eventBus.put(eventName, new LinkedList<>());
            return false;
        }
        return true;
    }

    public EventEmitter on(String eventName, Callback callback) {
        checkEmitter(eventName);

        eventBus.get(eventName).add(callback);
        return this;
    }

    public EventEmitter on(String eventName, NoArgsCallback noArgsCallback) {
        return on(eventName, (Callback)noArgsCallback);
    }

    public EventEmitter on(String eventName, ArgsCallback argsCallback) {
        return on(eventName, (Callback)argsCallback);
    }


}

执行

public static void main(String[] args) {

        EventEmitter emitter = new EventEmitter();

        new Thread(new Runnable() {
            @Override
            public void run() {
                int msg = 0;
                while (true) {
                    emitter.emit("打招呼", "你好：" + msg);
                    msg++;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }).start();

        emitter.on("打招呼", new ArgsCallback() {
            @Override
            public void invoke(Object[] args) {
                System.out.println("收到问候语1：" + Arrays.toString(args));
            }
        }).on("打招呼", new ArgsCallback() {
            @Override
            public void invoke(Object[] args) {
                System.out.println("收到问候语2：" + Arrays.toString(args));
            }
        }).on("打招呼", new ArgsCallback() {
            @Override
            public void invoke(Object[] args) {
                System.out.println("收到问候语3：" + Arrays.toString(args));
            }
        });