Event事件简单实现

概要

• 在项目启动时将所有可能触发的事件处理类注册到spring容器中并使用注解进行标记
• 通过注解获取所有的事件处理类，获取到要触发的方法，将事件和事件处理类存放到map集合进行绑定
• 在进行调用的时候在该map集合中进行查找，并对查询到的事件处理类进行执行

具体实现

• 事件接口以及实现

/**
 * 事件接口
 */
public interface IEvent {
}

/**
 * 具体事件
*/
@Data
public class TestEvent implements IEvent {
    public Integer id;
}

• 事件处理类

public interface EventHandlerI<T>{
    /**
     * 如果需要 启动自己单独的线程进行执行
     * @return
     */
    default ExecutorService getExecutor() { return null;}

    public String execute(T t);
}

@Slf4j
@EventHandler
@Component
public class TestEventHandler implements EventHandlerI<TestEvent> {
    @Override
    public String execute(TestEvent testEvent) {
        log.info("员工id:{}的邮箱申请成功", testEvent.getId());
        return null;
    }
}

• 事件存放处理

@Component
public class EventHub {

    // list-》多个处理器同时监听同一方法的执行
    private HashMap<Class, List<EventHandlerI>> eventHandlerRepository = new HashMap<>();

    /**
     * 获取
     * @param eve
     * @return
     */
    public List<EventHandlerI> getEventHandler(Class<? extends IEvent> eve) {
        List<EventHandlerI> handler = findHandler(eve);
        if (handler == null || handler.size() == 0){
            throw new RuntimeException(eve.getName() + "is not registered in eventHub, please register first");
        }
        return handler;
    }

    public void register(Class< ? extends IEvent> event,EventHandlerI eventHandler){
        List<EventHandlerI> eventHandlers = eventHandlerRepository.get(event);
        if (eventHandlers == null) {
            eventHandlers = new ArrayList<>();
            // 判断该方法之前是否有其他方法已经注册
            eventHandlerRepository.put(event, eventHandlers);
        }
        eventHandlers.add(eventHandler);
    }

    /**
     * 查找
     * @param eve
     * @return
     */
    public List<EventHandlerI> findHandler(Class<? extends IEvent> eve) {
        List<EventHandlerI> eventHandlers = eventHandlerRepository.get(eve);
        return eventHandlers;
    }

• 事件注册

@Component
@Slf4j
public class EventRegister {
    @Autowired
    private EventHub eventHub;


    public Class<? extends IEvent> getEventFromExecutor(Class<?> eventExecutorClz){
        // 获取当前类所有声明的方法
        Method[] declaredMethods = eventExecutorClz.getDeclaredMethods();
        for (Method method : declaredMethods) {
            // 根据方法名进行判断 排除自动生成的桥接方法
            if ("execute".equals(method.getName()) && !method.isBridge()){
                // 判断参数个数
                Class<?>[] parameterTypes = method.getParameterTypes();
                if (parameterTypes.length == 0){
                    log.error("execute method should at least have one param");
                }

                if (!IEvent.class.isAssignableFrom(parameterTypes[0])){
                    log.error("execute method should the subClass of event ");
                }
                return (Class)parameterTypes[0];
            }
        }
        throw new RuntimeException("异常");
    }

    /**
     * 进行事件注册
     * @param eventHandlerI
     */
    public void doRegisteration(EventHandlerI eventHandlerI){
        Class<? extends IEvent> eventClz= getEventFromExecutor(eventHandlerI.getClass());
        eventHub.register(eventClz, eventHandlerI);
    }
}

• EventBus触发事件时调用

@Slf4j
@Component
public class EventBus implements EventBusI {
    ExecutorService defaultExecutor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors() + 1,
            Runtime.getRuntime().availableProcessors() + 1,
            0L, TimeUnit.MICROSECONDS,
            new LinkedBlockingDeque<>(100));

    @Autowired
    private EventHub eventHub;

    @Override
    public void asyncFire(IEvent event) {
        eventHub.getEventHandler(event.getClass()).parallelStream().map(p -> {
            String res = null;
            try {
                if (null != p.getExecutor()) {
                    p.getExecutor().submit(() -> p.execute(event));
                } else {
                    defaultExecutor.submit(() -> p.execute(event));
                }
            } catch (Exception exception) {
                log.error("线程提交执行异常{}暂未实现处理", exception);
            }
            return "";
        }).collect(Collectors.toList());
    }
}

• 将事件处理类注册到spring上下文当中

public class EventConfig{
    @Resource
    private EventRegister eventRegister;

    /**
     * 事件注册到spring上下文当中
     */
    public void init() {
        // 获取spring上下文
        ApplicationContext applicationContext = ApplicationContextHelper.getApplicationContext();
        // 通过所有的被 @EventHandler注解修饰的类
        Map<String, Object> beansWithAnnotation = applicationContext.getBeansWithAnnotation(EventHandler.class);
        // 遍历对事件进行注册
        beansWithAnnotation.values().stream().forEach(o -> eventRegister.doRegisteration((EventHandlerI) o));
    }

}