从spring源码汲取营养：模仿spring事件发布机制，解耦业务代码

前言

最近在项目中做了一项优化，对业务代码进行解耦。我们部门做的是警用系统，通俗的说，可理解为110报警。一条警情，会先后经过接警员、处警调度员、一线警员，警情是需要记录每一步的日志，是要可追溯的，比如报警人张小三在2019-12-02 00:02:01时间报警，接警员A在1分钟后，将该警情记录完成，并分派给处警调度员B，调度员B在5分钟后，分派给一线警员C，C赶到现场后，花了1个小时处理完成。

这中间，每一个接口，需要做的事情，可能就包括了：警情日志记录；警员当前任务数统计，包括待处置的任务和已经处置完成的任务；我们其实还有一个操作，就是发mq，去通知其他相关人，比如接警员A接警完成后，要发mq通知其主管。

以前的代码可能是这样的：

## 接口1里， 接收警情service里完成以下操作
void 接收警情(xxxReqVo reqVo){
  1：写库
  2：记录警情跟踪日志
  3：增加当前接警员的接警数
  4：发mq通知其他相关人
}

##接口2里，分派警情的service里完成以下操作
void 分派警情(xxxReqVo reqVo){
  1：写库
  2：记录警情跟踪日志
  3：增加当前处警调度警员的处警数
  4：发mq通知其他相关人
}

这样的问题是什么呢？

在每一个相关接口里，都要“显式”调用：记录跟踪日志的相关方法、统计相关的方法、发mq相关的方法；但凡有一个地方忘记了，都会导致问题，比如统计数量不准，mq忘发，跟踪日志遗漏等。
业务逻辑和这类通用业务揉在一起，假设下次又需要给报警人发个短信，岂不是又得去改核心代码？这不符合我们“对修改关闭，对扩展开放”的开闭原则啊；假设脑残的产品经理，这次说要给报警人发短信，过两天又不要了，难道每个接口，挨个挨个改吗，想想都想打死产品经理，但是这个又犯法，还是想想其他办法？

这个问题，我们可以用类似mq的方法来解决，即，发送消息，各个消费者去消费。一般，mq的方式适用于微服务之间，而我们这里，将使用事件-发布机制来解决这个问题。
源码地址（直接dubug跟一下，很简单，比看文章来得快）：
https://gitee.com/ckl111/spring-event-publish-demo

先说说ApplicationListener

在spring boot之前的spring 时代，想必一些同学用过org.springframework.context.ApplicationListener，正好我手里有一个老项目，也用到了这个东西，我就拿这个举个例子：

在我们的项目中，需要在启动后，初始化一些东西，比如预热缓存，最早的代码呢，可能是大家各自实现org.springframework.beans.factory.InitializingBean，但是这样呢，初始化代码散落在各个service中；还有一些直接使用@PostContruct注解，然后在对应方法里去完成一些初始化操作。但是总体来说，这些方式，在spring的启动过程中，被调用的时机比较靠前，有些候某些bean可能还没初始化完成，而导致一些奇怪的问题。

所以，我们后来统一去掉了这些初始化代码，全部采用以下机制来实现：

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;

@Service
public class InitRunner implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    private InitService initService;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        //root application context，因为是web项目，
        if (contextRefreshedEvent.getApplicationContext().getParent() == null) {
              initService.init();
        }
 }

在这个类中，我们实现了org.springframework.context.ApplicationListener<ContextRefreshedEvent> ，这个 listener的定义如下：

public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {

	/**
	 * Handle an application event.
	 * @param event the event to respond to
	 */
	void onApplicationEvent(E event);

}

接口 EventListener 是 jdk 的一个 marker interface：

package java.util;

/**

- A tagging interface that all event listener interfaces must extend.
- @since JDK1.1
  */
  public interface EventListener {
  }

我们在实现listener时，指定了本listener感兴趣的事件：ContextRefreshedEvent，这个事件的类继承关系如下：

那么，这个事件是什么意思呢？

/**
 * Event raised when an {@code ApplicationContext} gets initialized or refreshed.
 *
 * @author Juergen Hoeller
 * @since 04.03.2003
 * @see ContextClosedEvent
 */
@SuppressWarnings("serial")
public class ContextRefreshedEvent extends ApplicationContextEvent {

	/**
	 * Create a new ContextRefreshedEvent.
	 * @param source the {@code ApplicationContext} that has been initialized
	 * or refreshed (must not be {@code null})
	 */
	public ContextRefreshedEvent(ApplicationContext source) {
		super(source);
	}

}

注释说：Event raised when an {@code ApplicationContext} gets initialized or refreshed.，那么意思就是，该事件，是在上下文初始化完成后被发布。

这样的话，就能保证，在我们listener监听到这个事件的时候，整个应用上下文已经可以使用了。

一览Spring事件监听机制

我们再通过debug，来看看其真实的调用时机：

上图红框处，对spring上下文进行refresh，refresh就是spring 最核心的部分了，基本上，看懂了这个函数，就懂了一半：

// Prepare this context for refreshing.
prepareRefresh();

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// Prepare the bean factory for use in this context. 
// 实例化beanFactory
prepareBeanFactory(beanFactory);

try {
  // Allows post-processing of the bean factory in context subclasses.
  // 对beanFactory进行处理
  postProcessBeanFactory(beanFactory);

  // Invoke factory processors registered as beans in the context.
  // BeanFactoryPostProcessor开始作用的地方，这里会调用所有的beanFactory后置处理器
  invokeBeanFactoryPostProcessors(beanFactory);

  // Register bean processors that intercept bean creation.
  // 注册 bean的后置处理器到beanFactory，注意，截止目前，还没开始实例化bean（除了少数几个内部bean）
  registerBeanPostProcessors(beanFactory);

  // Initialize message source for this context. 
  // 注册国际化相关bean
  initMessageSource();

  // Initialize event multicaster for this context.
  // 注册事件发布器，这个和本文主题大有关系
  initApplicationEventMulticaster();

  // Initialize other special beans in specific context subclasses.
  //注意上面这行注释，这个类是交给子类覆盖的，比如，在 org.springframework.web.context.support.AbstractRefreshableWebApplicationContext中，实例化了	org.springframework.ui.context.ThemeSource
  onRefresh();

  // Check for listener beans and register them.
  // 从spring容器上下文中，查找ApplicationListener类型的监听器，添加到前两步，初始化的事件发布器中
  registerListeners();

  // Instantiate all remaining (non-lazy-init) singletons.
  //注意：截止到目前为止，beanFactory里面基本还是空空如也，没有bean，只有BeanDefinition，在这一步才会   //根据那些BeanDefinition来实例化那些：非lazy-init的bean
  finishBeanFactoryInitialization(beanFactory);

  // Last step: publish corresponding event.
  // 发布：容器完成初始化的事件
  finishRefresh();
}

上面基本都加了注释，比较容易懂，需要重点关注的是：

事件发布器初始化

initApplicationEventMulticaster();

这一步会生成一个org.springframework.context.event.ApplicationEventMulticaster，存储在org.springframework.context.support.AbstractApplicationContext#applicationEventMulticaster

该事件发布器的接口主要有（去除了无关方法）：

    /**
	 * Add a listener to be notified of all events.
	 * @param listener the listener to add
	 */
	void addApplicationListener(ApplicationListener<?> listener);

	/**
	 * Multicast the given application event to appropriate listeners.
	 * <p>Consider using {@link #multicastEvent(ApplicationEvent, ResolvableType)}
	 * if possible as it provides a better support for generics-based events.
	 * @param event the event to multicast
	 */
	void multicastEvent(ApplicationEvent event);

从上面可以看出，该接口主要是维护监听器ApplicationListener，以及进行事件发布。

注册监听器

// 注册listeners
protected void registerListeners() {
  // Register statically specified listeners first.
  for (ApplicationListener<?> listener : getApplicationListeners()) {
    getApplicationEventMulticaster().addApplicationListener(listener);
  }

  // Do not initialize FactoryBeans here: We need to leave all regular beans
  // uninitialized to let post-processors apply to them!
  //这里的这句注释也很魔性，哈哈，侧面说明了，截至目前，beanFactory都是没有bean实例存在的，bean还没   //有实例化
  String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
  for (String listenerBeanName : listenerBeanNames) {
    getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
  }

beanFactory初始化完成后，发布事件

protected void finishRefresh() {

  // Publish the final event.
  // 发布上下文refresh完毕的事件，通知listener
  publishEvent(new ContextRefreshedEvent(this));
}

这里，publishEvent实现如下：

	protected void publishEvent(Object event, ResolvableType eventType) {
		// Decorate event as an ApplicationEvent if necessary
		ApplicationEvent applicationEvent;
		if (event instanceof ApplicationEvent) {
			applicationEvent = (ApplicationEvent) event;
		}

		getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
	}

方案1：参考spring，实现自己的事件监听机制，解耦业务代码

项目源码地址：https://gitee.com/ckl111/spring-event-publish-demo.git

项目结构如下：

定义与实现事件发布器

package com.foo.base.event;

import org.springframework.context.event.ApplicationEventMulticaster;

/**
 * desc:
 * 参考spring的设计
 * {@link ApplicationEventMulticaster}
 * @author : ckl
 * creat_date: 2019/11/16 0016
 * creat_time: 10:40
 **/
public interface ICommonApplicationEventMulticaster {
    /**
     * Add a listener to be notified of all events.
     * @param listener the listener to add
     */
    void addApplicationListener(ICommonApplicationEventListener<?> listener);


    /**
     * Multicast the given application event to appropriate listeners.
     * @param event the event to multicast
     */
    void multicastEvent(CommonApplicationEvent event);


}

package com.foo.base.event;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.stereotype.Component;

import java.util.LinkedHashSet;
import java.util.Set;

/**
 * desc:
 * 参考spring
 * {@link SimpleApplicationEventMulticaster}
 *
 * @author : ckl
 * creat_date: 2019/11/16 0016
 * creat_time: 10:40
 **/
@Slf4j
@Component
public class CommonApplicationEventMulticaster implements ICommonApplicationEventMulticaster {
    public final Set<ICommonApplicationEventListener<?>> applicationListeners = new LinkedHashSet<>();

    @Override
    public void addApplicationListener(ICommonApplicationEventListener<?> listener) {
        applicationListeners.add(listener);
    }

    @Override
    public void removeApplicationListener(ICommonApplicationEventListener<?> listener) {
        applicationListeners.remove(listener);
    }

    @Override
    public void removeAllListeners() {
        applicationListeners.clear();
    }

    @Override
    @SuppressWarnings({"rawtypes", "unchecked"})
    public void multicastEvent(CommonApplicationEvent event) {
        try {
            for (ICommonApplicationEventListener applicationListener : applicationListeners) {
                //判断listener是否支持处理该事件，如果支持，则丢给listener处理
                if (applicationListener.supportsEventType(event)) {
                    applicationListener.onApplicationEvent(event);
                }
            }
        } catch (Exception e) {
            log.error("{}",e);
        }
    }
}

定义listener

package com.foo.base.event;

import org.springframework.context.ApplicationListener;

import java.util.EventListener;

/**
 * desc:
 * 参考spring
 * {@link ApplicationListener}
 * @author : ckl
 * creat_date: 2019/11/16 0016
 * creat_time: 10:45
 **/
public interface ICommonApplicationEventListener<E extends CommonApplicationEvent> extends EventListener {


    boolean supportsEventType(E event );


    /**
     * Handle an application event.
     * @param event the event to respond to
     */
    void onApplicationEvent(E event);
}

定义事件类

package com.foo.base.event;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.experimental.Accessors;

import java.util.EventObject;

/**
 * desc:
 * 参考spring的设计
 * {@link org.springframework.context.ApplicationEvent}
 **/
@Data
@AllArgsConstructor
@Accessors(chain = true)
public  class  CommonApplicationEvent<T>{
    /**
     * 事件类型
     */
    private  IEventType iEventType;

    /**
     * 事件携带的数据
     */
    private T data;

}

listener的样例实现，下面的实现，用于警情的跟踪日志记录

package com.foo.base.listener;

import com.foo.base.applicationevent.SystemEventType;
import com.foo.base.event.CommonApplicationEvent;
import com.foo.base.event.ICommonApplicationEventListener;
import com.foo.base.eventmsg.*;
import com.foo.base.service.IIncidentTraceService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * desc:
 * 接警统计listener
 * @author : ckl
 * creat_date: 2019/11/16 0016
 * creat_time: 9:56
 **/
@Component
@Slf4j
public class IncidentTraceListener implements ICommonApplicationEventListener{
    @Autowired
    private IIncidentTraceService iIncidentTraceService;

    @Override
    public boolean supportsEventType(CommonApplicationEvent event) {
        return true;
    }

    @Override
    public void onApplicationEvent(CommonApplicationEvent event) {
        log.info("{}",event);
        Object data = event.getData();
        if (event.getIEventType() == SystemEventType.FINISH_INCIDENT_APPEAL) {
            FinishIncidentDisposalEventMsg msg = (FinishIncidentDisposalEventMsg) data;
            iIncidentTraceService.finishIncidentDisposal(msg);
        }
    }
}

启动程序时，注册listener到事件发布器

package com.foo.base.init;

import com.foo.base.event.CommonApplicationEventMulticaster;
import com.foo.base.event.ICommonApplicationEventListener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.Map;

/**
 * desc:
 *
 * @author : ckl
 * creat_date: 2019/11/11 0011
 * creat_time: 15:46
 **/
@Component
@Slf4j
public class InitRunner implements CommandLineRunner,ApplicationContextAware {


    private ApplicationContext applicationContext;

    @Autowired
    private CommonApplicationEventMulticaster commonApplicationEventMulticaster;

    @Override
    public void run(String... args) throws Exception {
        Map<String, ICommonApplicationEventListener> map = applicationContext.getBeansOfType(ICommonApplicationEventListener.class);
        Collection<ICommonApplicationEventListener> listeners = map.values();
        for (ICommonApplicationEventListener listener : listeners) {
            /**
             * 注册事件listener到事件发布器
             */
            log.info("register listener:{}",listener);
            commonApplicationEventMulticaster.addApplicationListener(listener);
        }

    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

定义endpoint，在service中进行事件发布

controller:

@Autowired
private IIncidentService iIncidentService;

@RequestMapping("/test.do")
public String finishIncident() {
  iIncidentService.finishIncident();
  return "success";
}

service:

@Slf4j
@Service
public class IIncidentServiceImpl implements IIncidentService {

    @Autowired
    private CommonApplicationEventMulticaster commonApplicationEventMulticaster;


    @Override
    public void finishIncident() {
        FinishIncidentDisposalEventMsg msg = new FinishIncidentDisposalEventMsg();
        msg.setIncidentInformationId(1111L);
        msg.setDesc("处置完成");

        CommonApplicationEvent event = new CommonApplicationEvent(SystemEventType.FINISH_INCIDENT_APPEAL,msg);
        commonApplicationEventMulticaster.multicastEvent(event);
    }
}

效果展示

启动时，注册listener：

2019-12-03 16:49:47.477  INFO 493432 --- [           main] com.foo.base.BootStrap                 : Started BootStrap in 1.436 seconds (JVM running for 2.22)
2019-12-03 16:49:47.478  INFO 493432 --- [           main] com.foo.base.init.InitRunner           : register listener:com.foo.base.listener.IncidentStatisticsListener@c6b2dd9
2019-12-03 16:49:47.479  INFO 493432 --- [           main] com.foo.base.init.InitRunner           : register listener:com.foo.base.listener.IncidentTraceListener@3f985a86
2019-12-03 16:49:47.479  INFO 493432 --- [           main] com.foo.base.init.InitRunner           : register listener:com.foo.base.listener.MqListener@57a2ed35

浏览器中，请求http://localhost:8081/test.do，日志如下：

方案2：直接使用spring内置的事件发布器，解耦业务代码

源码：https://gitee.com/ckl111/spring-event-publish-demo/tree/master/spring-event-use-builtin-multicaster

这部分，比上面的方案相比，少了很多东西，只包含如下部分：

总的来说，listener直接继承spring的ApplicationListener，事件发布器直接使用spring的org.springframework.context.ApplicationEventPublisher

核心代码：

package com.foo.base.service.impl;

import com.foo.base.applicationevent.SystemEventType;
import com.foo.base.event.CommonApplicationEvent;
import com.foo.base.eventmsg.FinishIncidentDisposalEventMsg;
import com.foo.base.service.IIncidentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

/**
 * desc:
 * 发布事件的业务代码示例
 * @author : ckl
 * creat_date: 2019/12/2 0002
 * creat_time: 14:27
 **/
@Slf4j
@Service
public class IIncidentServiceImpl implements IIncidentService {

    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;


    @Override
    public void finishIncident() {
        FinishIncidentDisposalEventMsg msg = new FinishIncidentDisposalEventMsg();
        msg.setIncidentInformationId(1111L);
        msg.setDesc("处置完成");

        CommonApplicationEvent event = new CommonApplicationEvent(SystemEventType.FINISH_INCIDENT_APPEAL,msg);
        applicationEventPublisher.publishEvent(event);
    }
}

package com.foo.base.listener;

import com.foo.base.applicationevent.SystemEventType;
import com.foo.base.event.CommonApplicationEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

/**
 * desc:
 * 这里，直接继承 spring 的listener
 * @author : ckl
 * creat_date: 2019/11/16 0016
 * creat_time: 9:56
 **/
@Component
@Slf4j
public class IncidentStatisticsListener implements ApplicationListener<CommonApplicationEvent> {



    @Override
    public void onApplicationEvent(CommonApplicationEvent event) {
        log.info("receive event:{}",event);
    }
}

总结

以上两种都可以用，一个是自己仿的，定制性强一点；一个直接用spring的。大家自由选择即可。

通过这样的方式，我们的业务代码，可以做到解耦，大体和mq其实是类似的。

posted @ 2019-12-03 18:08 三国梦回阅读(2050) 评论(1) 编辑收藏举报

刷新页面返回顶部

低级知识传播者

实战问题分享，关注框架源码、网络编程、效率工具

从spring源码汲取营养：模仿spring事件发布机制，解耦业务代码

前言

先说说ApplicationListener

一览Spring事件监听机制

方案1：参考spring，实现自己的事件监听机制，解耦业务代码

方案2：直接使用spring内置的事件发布器，解耦业务代码

总结

公告