SpringEvent与分发器模式

分发器模式实际上是监听模式的一种扩展。由事件Event驱动，每当有事件产生时，由事件分发器（EventDispatcher）分发给特定的事件处理器(Handler)处理该事件

关键词：事件处理、观察者模式、Spring事件

感觉很像Spring事件，后续增加Spring事件简单示例至此文档

事件类型

Handler事件处理器由事件类型进行区分，同时Event事件中需要带有该类型，这样dispatcher分发器才能根据类型进行分发事件。在此示例中，我们使用枚举类创建事件类型，事件类型使用枚举类中的key值，即事件类型为数字标识。

import lombok.Getter;

/**
 * 事件类型枚举类
 *
 * @author 
 * @date 2022/11/25
 */
@Getter
public enum EventTypeEnum {
    /**
     * 类型
     */
    ERROR(201, "错误"),
    WARNING(202, "警告"),
    INFO(203, "信息"),
		;

    private Integer key;
    private String value;

    EventTypeEnum(Integer key, String value) {
        this.key = key;
        this.value = value;
    }
}

事件

有了事件类型后，我们来创建事件，事件的定义很简答，只需要包括事件类型、事件数据两个元素即可，这里使用泛型来存储事件数据。以下类中sendTime、idSceneInfo字段可去掉。

import lombok.Data;
/**
 * 事件类
 *
 * @author 
 * @date 2022/11/25
 */
@Data
public class Event<T> {
    /**
     * 事件类型
     */
    private Integer msgType;
    /**
     * 时间戳
     */
    private Long sendTime;
    /**
     * 场景ID
     */
    private String sceneId;
    /**
     * 各类型消息数据
     */
    private T data;
}

事件分发器、事件调度

首先我们抽象出事件处理接口，后面的事件处理类（*Handler.class）都需要实现此接口

HandleEventService.java

package com.xf.dispatcher;

/**
 * 事件数据处理接口类
 *
 * @author xiongfeng
 * @date 2023/11/22
 */
public interface HandleEventService  {
    /**
     * 处理事件数据
     *
     * @param event 事件数据
     */
    void handleEventData(Event<Object> event);
}

dispatcher分发器需要以下功能

• register方法存储不同类型的事件处理者handler，handler类似于Spring事件中的事件监听者
• getEventHandle 提供获取handler的方法
• handleEventData 事件处理方法，该接口不负责具体的事件业务处理，而是将事件分发给handler进行业务处理

EventDispatcher分配者中的AbstractEventHandler为事件处理抽象类，将在下一步实现它

EventDispatcher.java

package com.xf.dispatcher;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.concurrent.ConcurrentHashMap;

/**
 * 回调数据处理委托类
 *
 * @author xiongfeng
 * @date 2023/11/22
 */
@Component
@Slf4j
public class EventDispatcher implements HandleEventService {

    /**
     * 使用ConcurrentHashMap存储处理类handler
     */
    private static final ConcurrentHashMap<Integer, AbstractEventHandler> DISPATCHER = new ConcurrentHashMap<>();

    /**
     * 添加处理器
     */
    public static void register(AbstractEventHandler handle) {
        DISPATCHER.put(handle.getType(), handle);
    }

    /**
     * 获取处理器
     *
     * @param type 事件类型类型枚举值
     * @return 处理器
     */
    public AbstractEventHandler getEventHandle(Integer type) {
        return DISPATCHER.get(type);
    }

    /**
     * 根据事件中的事件类型MsgType，将数据分配给不同处理类处理
     *
     * @param event 事件数据
     */
    @Override
    public void handleEventData(Event<Object> event) {
        AbstractEventHandler handler = this.getEventHandle(event.getMsgType());
        if (handler == null) {
            log.info("未找到相应的事件处理类,事件:{}", event);
            return;
        }
        handler.handleEventData(event);
    }
}

事件处理类

抽象事件处理类

• getType()抽象方法，子类需要实现此方法，这样在注册至Dispatcher时，Dispacher通过该方法获取handler的事件类型
• AbstractEventHandler()构造方法，通过此方法实现注册
• HandleEventService 接口，该抽象类implements 该接口，子类需要实现该方法，实现具体的业务处理

AbstractEventHandler.class

package com.xf.dispatcher;

/**
 * Handler抽象类
 *
 * @author xiongfeng
 * @date 2023/11/22
 */
public abstract class AbstractEventHandler implements HandleEventService {

    /**
     * 获取事件类型
     *
     * @return CallbackTypeEnum
     */
    protected abstract Integer getType();

    /**
     * 无参构造方法
     * 继承该抽象类的事件处理类在构造时将调用此方法，通过此方法将处理类注册至分发器Dispatcher
     */
    AbstractEventHandler() {
        EventDispatcher.register(this);
    }
}

事件处理类

这里只展示ErrorEventHandler.java，其余WarnEventHandler.java、InfoEventHandler.java与其类似

ErrorEventHandler.java

package com.xf.dispatcher;

import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * ERROR事件处理器
 *
 * @author xiongfeng
 * @date 2023/11/22
 */
@Slf4j
@Component
@AllArgsConstructor
public class ErrorEventHandler extends AbstractEventHandler {
    /**
     * 获取处理器的类型
     *
     * @return
     */
    @Override
    protected Integer getType() {
        return EventTypeEnum.ERROR.getKey();
    }

    /**
     * 具体的数据处理
     *
     * @param event 事件数据
     */
    @Override
    public void handleEventData(Event<Object> event) {
        // ...
        log.info("ERROR事件处理器,处理事件：{}", event);
    }
}

使用

在使用时只需要获取Dispatcher分发器的实例对象，通过该对象的handleEventData()即可将Event分配给不同的Handler进行处理

@RestController
@AllArgsConstructor
@RequestMapping("/ignore")
@Slf4j
public class TestController {

    private final EventDispatcher eventDispatcher;

    /**
     * 接受机器人系统的数据回调
     *
     * @param robotPostCommonResult 通用Result
     * @return stringSuccess
     */
    @PostMapping("/test")
    public Result<String> test(@RequestBody Event<Object> event) {
        eventDispatcher.handleEventData(event);
        return Result.success("事件处理成功");
    }

}