Spring事件传播机制

    Spring是基于事件驱动模型的，事件驱动模型也就是我们常说的观察者，或者发布-订阅模型。理解观察者模式更有助于理解 Spring 事件机制，话不多说，我们先来看一下 Spring 的事件角色的类图


Spring 的事件角色的类图.png

    从此类图中我们可以得到以下信息：
    1.事件源：如果我们需要实现事件传播的话，我们首先需要实现自己的事件类去实现 ApplicationEvent 接口。
    2.监听者：需要定义自己的事件监听器类去实现 ApplicationListener<E extends ApplicationEvent> 接口。
    3.事件发布：需要有一个对象去发布该事件，从类图中我们可以了解到，应用上下文 ApplicationContext 就是一个天生的事件发布源。我们通常可以 事件ApplicationEventPublisherAware接口来注入上下文中的 ApplicationEventPublisher，既可以通过它发布事件

    需要知道的是，在spring源码中 AbstractApplicationContext 持有了 ApplicationEventMulticaster引用，且通过他进行事件的发布，默认实现为 SimpleApplicationEventMulticaster。那么了解了这些，我们可以来简单实现一下我们的spring自定义事件：

1.定义一个类，及源事件：

public class Order {
    private String orderNo;
    private String orderStatus;
    private String goods;
    private Date createTime;
    //省略 get/set
}
//源事件
public class OrderCreateEvent extends ApplicationEvent {

    private final Order order;

    public OrderCreateEvent(Object source, Order order) {
        super(source);
        this.order = order;
    }

    public Order getOrder() {
        return order;
    }
}

2.定义事件监听器：

@Component
public class OrderCreateEventListener implements ApplicationListener<OrderCreateEvent> {

    @Override
    public void onApplicationEvent(OrderCreateEvent event) {
        System.out.printf(this.getClass().getName() + " -- ApplicationListener 接口实现，订单号[%s]：,商品[%s]\n",
                event.getOrder().getOrderNo(), event.getOrder().getGoods());
    }
}

3.定义事件发服务：

@Service
public class OrderService implements ApplicationEventPublisherAware {

    private ApplicationEventPublisher applicationEventPublisher;
    /**
     * 订单保存
     */
    public void save(){
        Order order = new Order();
        order.setOrderNo("1");
        order.setGoods("手机");
        System.out.println("订单保存成功：" + order.toString());
        //发布事件
        applicationEventPublisher.publishEvent(new OrderCreateEvent(this,order));
    }
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }
}

4.编写测试类：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringStudyApp.class)
public class SpringStudyTest {

    @Autowired
    OrderService orderService;

    @Test
    public void contextLoads() {
        orderService.save();
    }
}

    简单的几步就实现了自定义的spring事件。

基于注解的事件监听@EventListener：

@Component
public class OrderCreateEventListenerAnnotation {
    @EventListener
    public void createOrderEvent(OrderCreateEvent event) {
        System.out.println(this.getClass().getName() + "--订单创建事件，@EventListener注解实现，orderNo:" + event.getOrder().getOrderNo());
    }
}

异步事件：
　　上面的监听事件都是同步触发的，如果想异步只需要两步：

  1. 启动类上添加 @EnableAsync注解，开启异步支持。
  2. 监听方法上添加 @Async注解
    事件传播机制：
    　　当我们监听一个事件处理完成时，还需要发布另一个事件，一般我们想到的是调用ApplicationEventPublisher#publishEvent发布事件方法，但Spring提供了另一种更加灵活的新的事件继续传播机制，监听方法返回一个事件，也就是方法的返回值就是一个事件对象
@Component
public class OrderListener {

    @EventListener
    public void orderListener(Order order){
        System.out.println(this.getClass().getName() + " -- 监听一个订单");
    }
//事件传播机制
//    当我们监听一个事件处理完成时，还需要发布另一个事件，一般我们想到的是调用ApplicationEventPublisher#publishEvent发布事件方法，
//    但Spring提供了另一种更加灵活的新的事件继续传播机制，监听方法返回一个事件，也就是方法的返回值就是一个事件对象。
    @EventListener
    public OrderCreateEvent orderReturnEvent(Order order){
        System.out.println(this.getClass().getName() + " -- 监听一个订单,返回一个新的事件 OrderCreateEvent");
        return new OrderCreateEvent(this,order);
    }
}

    这样子我们后续通过 applicationEventPublisher.publishEvent(order); 发布一个 Order 类型的参数的事件，他会被上面的 orderReturnEvent 方法监听到，然后最后返回一个 OrderCreateEvent 事件对象，继而触发该事件的监听。

    基于事件驱动模型可以很方便的实现解耦，提高代码的可读性和可维护性，那么 Spring中是怎么进行初始化及使用的呢？我们来一探究竟。

Spring 事件源码分析：
    我们知道 Spring 容器的初始化都会走到 AbstractApplicationContext 的 refresh() 方法：

@Override
public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // 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.
            prepareBeanFactory(beanFactory);

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

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();
                // 关键来了，为此上下文初始化事件多播程序
                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();
                // 调用子类特殊的某些特殊的方法刷新容器
                // Initialize other special beans in specific context subclasses.
                onRefresh();
                // 检查侦听器bean并注册它们。
                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);
　　　　　　　　　
                // Last step: publish corresponding event.
                finishRefresh();
            }
        }
}

    直接来看 initApplicationEventMulticaster() 方法：

public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
protected void initApplicationEventMulticaster() {
　　　　　// 获取上面初始化的 DefaultListableBeanFactory 容器
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        // 如果容器里找到了这个类，那么直接赋值给成员变量
            this.applicationEventMulticaster =
                    beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
            if (logger.isDebugEnabled()) {
                logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
            }
        }
        else {// 初始化一个 SimpleApplicationEventMulticaster
            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
            beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
                        APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
                        "': using default [" + this.applicationEventMulticaster + "]");
            }
        }
    }

    其实这个方法主要的作用是保证容器中又一个被实例化的ApplicationEventMulticaster 类型的Bean。紧接着等待子类特殊的刷新方法结束基本上整个容器也就初始化完成了。然后调用 registerListeners()：

private final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();
//注册监听器
protected void registerListeners() {
        // Register statically specified listeners first.
        for (ApplicationListener<?> listener : getApplicationListeners()) {
　　　　　　　// 遍历上面这个集合，将提前储备好的监听器添加到监听器容器中
            getApplicationEventMulticaster().addApplicationListener(listener);
        }
　　　　 // 获得容器中类型是 ApplicationListener 的 beanName集合
        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let post-processors apply to them!
        String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
        for (String listenerBeanName : listenerBeanNames) {
            getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }
        // 发布这个 earlyApplicationEvents 容器中的事件
        // Publish early application events now that we finally have a multicaster...
        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
        this.earlyApplicationEvents = null;
        if (earlyEventsToProcess != null) {
            for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
                // 委派上面初始化的 SimpleApplicationEventMulticaster 进行广播发布
                getApplicationEventMulticaster().multicastEvent(earlyEvent);
            }
        }
    }

    紧接着来看 multicastEvent(ApplicationEvent event)：

@Override
public void multicastEvent(ApplicationEvent event) {
　　multicastEvent(event, resolveDefaultEventType(event));
}

@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
　　　　　// 再去通过event去获得一个ResolvableType
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        // 通过事件及类型进行获取事件监听器进行遍历
        for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            Executor executor = getTaskExecutor();
            // 当 executor 不为空，这里走的是异步事件
            if (executor != null) {
                executor.execute(() -> invokeListener(listener, event));
            }
            // 同步事件
            else {
                invokeListener(listener, event);
            }
        }
}

    从这里去调用 listener 的 onApplicationEvent 方法：

private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
    try {
        listener.onApplicationEvent(event);
    }
    //.....省略部分代码
}

    像容器初始化完成，AbstractApplicationContext的 finishRefresh() 方法中

protected void finishRefresh() {
        // Clear context-level resource caches (such as ASM metadata from scanning).
        clearResourceCaches();

        // Initialize lifecycle processor for this context.
        initLifecycleProcessor();

        // Propagate refresh to lifecycle processor first.
        getLifecycleProcessor().onRefresh();
                // 发布容器刷新完成事件
        // Publish the final event.
        publishEvent(new ContextRefreshedEvent(this));

        // Participate in LiveBeansView MBean, if active.
        LiveBeansView.registerApplicationContext(this);
}

    这里所调用的 publishEvent(new ContextRefreshedEvent(this)) 最终还是走 multicastEvent(ApplicationEvent event) 方法的。这就是Spring事件的基本处理流程。

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 196,264评论 5赞 462
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 82,549评论 2赞 373
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 143,389评论 0赞 325
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,616评论 1赞 267
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,461评论 5赞 358
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,351评论 1赞 273
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,776评论 3赞 387
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,414评论 0赞 255
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,722评论 1赞 294
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,760评论 2赞 314
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,537评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,381评论 3赞 315
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,787评论 3赞 300
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,030评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,304评论 1赞 252
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,734评论 2赞 342
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,943评论 2赞 336