深入分析Spring事件驱动模型

一、事件驱动模型简介

事件驱动模型，也即是我们通常说的观察者。基于发布-订阅模式的编程模型。

概念
定义对象间的一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都得到通知并自动更新。

百度百科：
从事件角度说，事件驱动程序的基本结构是由一个事件收集器、一个事件发送器和一个事件处理器组成。
事件收集器专门负责收集所有事件，包括来自用户的（如鼠标、键盘事件等）、来自硬件的（如时钟事件等）和来自软件的（如操作系统、应用程序本身等）。
事件发送器负责将收集器收集到的事件分发到目标对象中。
事件处理器做具体的事件响应工作。

从程序设计的角度来看，事件驱动模型的核心构件通常包含以下几个：

1. 事件源：负责产生事件的对象。比如我们常见的按钮，按钮就是一个事件源，能够产生“点击”这个事件

2. 事件监听器（事件处理器）：负责处理事件的对象

3. 事件：或者称为事件对象，是事件源和事件监听器之间的信息桥梁。是整个事件模型驱动的核心

下图展示了事件、事件源、监听器直接的关系：

举个例子：

产品经理经过百般调研和思考过后提出开发一个新系统，确定需求后将需求录入到需求管理系统，这时开发人员得知确认需求后开始进入技术开发阶段。

在这个例子中，“产品经理”就是一个事件源，事件对象是“开发一个新系统”，然后“开发人员”就是一个事件监听器或者事件处理器，负责新系统的开发。那么此处为什么是开发人员开发需求，而不是销售人员开发需求呢？所以一个事件监听器要能够处理某个事件，需要提前建立某种关系。这种关系的建立采用事件驱动模型来表达就是注册或者订阅。当某种关系建立后，事件监听器才能处理相关联的事件，也就是开发人员来开发需求，而不是销售人员来开发需求。

事件监听器监听其感兴趣的事件，当事件源发布事件时，便能得到通知。

二、事件模型的应用

基于事件模型驱动的程序设计，笔者在开发过程中比较常遇到的关于事件驱动模型的应用包括以下几类：

1. 观察这模式
2. JDK观察者模式
3. JavaBean事件驱动
4. Spring事件驱动

下面对着4类事件驱动模型进行详细介绍，包括原理介绍和给出可运行的案例。

1、 观察者模式

原理解析

观察者模式的UML图如下：

具体类说明如下：

1. Observer观察者，即为事件模型中的事件监听器，该接口定义一个方法update，即为事件处理方法。当观察到有事件产生时，该方法便会处理
2. Subject被观察者，即事件模型中的事件源，负责产生事件，定义与观察者建立关联的方法（添加观察者、删除观察者、通知观察者）
3. ConreteObserver具体的观察者实现类，实现Observer接口中的update方法，具体实例会被添加到被观察者的观察者队列中（observers[List]）
4. ConreteSubject具体的被观察者实现类，实现Subject接口。定义观察者队列（observers[List]），并定义实现如何将观察者对象添加到观察者队列中以及如何通所有知观察者

在上述类图中，具体的ConreteSubject被观察者，其中包含observers一个列表，保存所有观察者对象。doAction方法是需要通知观察者对象的动作，当该方法执行后，会通知保存在observers中的所有观察者。

也就是在执行方法ConreteSubject#doAction()时，需要调用ConreteSubject#notifyObservers()通知保存在observers中的所有观察者，让其能够做出相应。

案例

上面描述感觉有点晦涩，我们举个例子：

以支付状态更新通知为例，自定义观察者设计模式，当支付状态更新时，通知邮件服务和库存服务。

1、 Observer接口及实现类

/**
 * Created by zhurudong on 2017/10/21.
 * 观察者
 */
public interface Observer {
    void update();
}

/**
 * Created by zhurudong on 2017/10/21.
 * 库存服务
 */
public class MyStockObserver implements Observer {
    @Override
    public void update() {
        System.out.println("库存服务收到通知");
    }
}


/**
 * Created by zhurudong on 2017/10/21.
 * 邮件服务
 */
public class MyEmailObserver implements Observer{
    @Override
    public void update() {
        System.out.println("邮件服务收到通知.");
    }
}

2、 Subjest接口及实现类

/**
 * Created by zhurudong on 2017/10/21.
 * 被观察者
 */
public interface Subject {
    /**
     * 添加观察者
     * @param observer
     */
    void addObserver(Observer observer);

    /**
     * 删除观察者
     * @param observer
     */
    void removeObserver(Observer observer);

    /**
     * 通知观察者
     */
    void notifyObservers();
}

/**
 * Created by zhurudong on 2017/10/21.
 *
 * 更改支付状态的被观察则
 */
public class MyPaymentStatusUpdateSubject implements Subject {

    private List observers = new Vector<>();

    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }

    public void updatePaymentStatus(int newStatus) {

        // 业务逻辑操作
        System.out.println("更新新的支付状态为：" + newStatus);

        // 通知观察者
        this.notifyObservers();
    }
}

3、 测试类

/**
 * Created by zhurudong on 2017/10/21.
 *
 * 观察者模式
 */
public class Test {
    public static void main(String[] args) {

        // "支付状态更新"->看做一个事件，可以被监听的事件

        // 被观察者。即事件源
        MyPaymentStatusUpdateSubject myPaymentStatusUpdateSubject = new MyPaymentStatusUpdateSubject();

        // 观察者。即事件监听器
        MyEmailObserver myEmailObserver = new MyEmailObserver();
        MyStockObserver myStockObserver = new MyStockObserver();

        // 添加观察者。
        myPaymentStatusUpdateSubject.addObserver(myEmailObserver);
        myPaymentStatusUpdateSubject.addObserver(myStockObserver);

        // 发布事件。支付状态更新。
        myPaymentStatusUpdateSubject.updatePaymentStatus(2);
    }
}

在这个例子中邮件服务和库存服务就是监听器，监听“支付状态变更”这一事件，由事件源MyPaymentStatusUpdateSubject产生此事件，当调用myPaymentStatusUpdateSubject#updatePaymentStatus(2);方法发布事件时，会通知所有的监听器，即库存服务和邮件服务，他们根据自己的业务逻辑做出不同的响应。

2、JDK中的观察者模式

原理解析

JDK已经帮我们实现了一个观察者模式，事件收集器采用Vector容器保存，操作事件收集器的方法都是线程安全的。

UML图如下：

跟上面我们自己实现的观察者模式十分类似，具体类说明如下：

1. Observer观察者
2. Observable可观察，即被观察者，是一个具体的类
3. ConreteObserver具体的观察者实现类
4. ConreteObservable具体的被观察者实现类，继承Observable类

观察发现，Observable可观察，即被观察者，已经实现了添加观察者、删除观察者、通知观察者等等操作事件收集器的方法，不用每个子类都要去实现一遍，只需要按照它的方式使用接口。

不同的是，我们做的是在执行方法ConreteObservable#doAction()时，在调用Observable#notifyObservers()通知观察者之前需要调用Observable#setChanged()表示可观察者状态已经发生改变，观察者可以对此做出想用。

案例

我们举个栗子：
还是“以支付状态更新通知为例，自定义观察者设计模式，当支付状态更新时，通知邮件服务和库存服务。”，下面看看类之间的关系：

1、 观察者接口

摘选JDK源码

public interface Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an Observable object's
     * notifyObservers method to have all the object's
     * observers notified of the change.
     *
     * @param   o     the observable object.
     * @param   arg   an argument passed to the notifyObservers
     *                 method.
     */
    void update(Observable o, Object arg);
}

2、可观察对象

摘选自JDK源码

package java.util;

/**
 * @author  Chris Warth
 * @see     java.util.Observable#notifyObservers()
 * @see     java.util.Observable#notifyObservers(java.lang.Object)
 * @see     java.util.Observer
 * @see     java.util.Observer#update(java.util.Observable, java.lang.Object)
 * @since   JDK1.0
 */
public class Observable {
    private boolean changed = false;
    private Vector obs;
    /** Construct an Observable with zero Observers. */
    public Observable() {
        obs = new Vector<>();
    }

    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    public void notifyObservers() {
        notifyObservers(null);
    }

    public void notifyObservers(Object arg) {
        Object[] arrLocal;
        synchronized (this) {
            /* 这里存在2个潜在的糟糕结果：
             * 1) 一个新加入的观察者错过了正在执行的通知
             * 2) 一个刚刚删除的观察者不需要关心变更时有可能会错误地被通知
             */
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }
        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    protected synchronized void setChanged() {
        changed = true;
    }

    protected synchronized void clearChanged() {
        changed = false;
    }

    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return obs.size();
    }
}

3、邮件服务和库存服务

/**
 * Created by zhurudong on 2017/10/21.
 * 邮件服务
 */
public class EmailObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("邮件服务收到通知");
    }
}

/**
 * Created by zhurudong on 2017/10/21.
 * 库存服务
 */
public class StockObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("库存服务收到通知");
    }
}

4、支付服务类

/**
 * Created by zhurudong on 2017/10/21.
 *
 * 支付状态变更做为一个可观察者
 */
public class PaymentStatusObservable extends Observable {

    public void updatePaymentStatus(int newStatus) {
        // 业务逻辑操作
        System.out.println("更新新的支付状态为：" + newStatus);

        // 通知观察者
        this.setChanged();//需要调用一下这这方法，表示被观察者的状态已发生变更，Observable才会通知观察者
        this.notifyObservers();
    }
}

5、测试类

/**
 * Created by zhurudong on 2017/10/21.
 *
 * 使用JDK中的观察者模式
 */
public class Test {

    public static void main(String[] args) {

        // "支付状态更新"->看做一个事件，可以被监听的事件

        // 被观察者。即事件源
        PaymentStatusObservable paymentStatusObservable = new PaymentStatusObservable();

        // 添加观察者
        paymentStatusObservable.addObserver(new EmailObserver());
        paymentStatusObservable.addObserver(new StockObserver());

        // 支付状态变更
        paymentStatusObservable.updatePaymentStatus(3);
    }
}

对于简单的事件模型驱动设计的程序采用JDK提供的API已经够用了，Observable类把观察者模式用到的方法几乎都实现了，省去了许多操作事件的编码工作。

但也正因为如此，Observable把部分的编码操作实现了，导致灵活性降低了，没有很好地进行抽象，而是几乎是给出了所有的实现。因此很多框架例如Spring在实现事件驱动的时候，没有直接使用JDK提供的API，而是大部分定义了自己的事件驱动模型。

我们针对JDK给出的观察者模式的解决方案总结几点：

1. Observable实现了大部分的逻辑，没有很好地进行抽象，灵活性降低了

2. 存在2个潜在的问题：一个刚刚加入的观察者错过了通知；一个刚刚删除的观察者被错误的通知

3. Observable实现的方法采用synchronized，操作同一个方法时串行，可能会存在效率问题

3、JavaBean中的事件驱动

原理解析

javabean规范中提供了一种监听属性变化的事件驱动模型。提供操作Javabean属性的类PropertyChangeSupport和PropertyEditorSupport。

从事件驱动模型的各个构建来分析，PropertyChangeSupport和PropertyEditorSupport都属于事件源，能够产生事件。如果以观察模式的角度来看，则是被观察者

事件监听器实现PropertyChangeListener接口，通过PropertyChangeSupport和PropertyEditorSupport添加到事件队列中。

一旦有Javabean属性发生变化通过调用PropertyChangeSupport#firePropertyChange()、PropertyEditorSupport#firePropertyChange()即可触发监听器处理事件。

JDK提供的API给我们展示了PropertyChangeSupport的用法，照葫芦画瓢写一个自己的示例。

案例

当一条订单支付状态更新时能够实时收到变更的通知。

1、事件源

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
/**
 * Created by zhurudong on 2017/10/21.
 */
public class PaymentStatusUpdateBean {

    PropertyChangeSupport paymentlisteners = new PropertyChangeSupport(this);

    public void updateStatus(int newStatus) {
        // 模拟业务逻辑
        System.out.println("支付状态更新： " + newStatus);
        // 触发通知
        paymentlisteners.firePropertyChange("paymentStatuUpdate", 0, newStatus);        ;
    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        paymentlisteners.addPropertyChangeListener(listener);
    }

    public void removePropertyChangeListener(PropertyChangeListener listener){
        paymentlisteners.addPropertyChangeListener(listener);
    }
}

2、事件监听器

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

/**
 * Created by zhurudong on 2017/10/21.
 * 支付状态变更的监听器
 */
public class PaymentStatusUpdateListener implements PropertyChangeListener {
    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        System.out.printf("支付状态变更. eventName : %s, oldValue : %s, newValue : %s", evt.getPropertyName(), evt.getOldValue(), evt.getNewValue());
    }
}

3、测试类

/**
 * Created by zhurudong on 2017/10/21.
 * 测试JDK提供的PropertyChangeEvent
 */
public class Test {
    public static void main(String[] args) {
        PaymentStatusUpdateBean paymentStatusUpdateBean = new PaymentStatusUpdateBean();

        // 添加监听器
        paymentStatusUpdateBean.addPropertyChangeListener(new PaymentStatusUpdateListener());

        // 更新支付状态
        paymentStatusUpdateBean.updateStatus(3);
    }
}

通过设定的PaymentstatusUpdateListener监听器可以实时地感知到支付状态发生的变化。

4、Spring事件驱动

Spring事件驱动模型原理比较复杂，涉及到的类比较多，我们先来看一个案例，从一个案例入手再逐渐理解Spring事件驱动模型。

1、 案例

跟之前的例子一样，当一个订单的支付状态发生变化时，能够通知到邮件服务、短信服务、库存服务。

首先先定义一个支付实体类，作为事件传输的信息载体

/**
 * Created by zhurudong on 2017/10/22.
 * 支付实体类
 */
public class PaymentInfo {

    private int id;
    private String stauts;

    public PaymentInfo(int id, String stauts) {
        this.id = id;
        this.stauts = stauts;
    }
    // 省略setter getter ....
    @Override
    public String toString() {
        return "PaymentInfo{" +
                "id=" + id +
                ", stauts='" + stauts + '\'' +
                '}';
    }
}

然后定义一个支付状态更新的事件，事件以PaymentInfo作为传输的载体，构建事件时需要将PaymentInfo实例化并传给PaymentStatusUpdateEvent事件对象

/**
 * 支付状态更新事件
 */
public class PaymentStatusUpdateEvent extends ApplicationEvent {
    /**
     * Create a new ApplicationEvent.
     *
     * @param source the object on which the event initially occurred (never {@code null})
     */
    public PaymentStatusUpdateEvent(PaymentInfo source) {
        super(source);
    }
}

定义事件监听器。为了满足各类场景的需求，伟大的Spring提供多种定义事件监听器。

1. 有序事件监听器：当多个监听器共同监听同一个事件时，该类是监听器可以按照事先定义好的顺序先后执行监听器，达到不同的监听器有序执行的目的。

2. 无序事件监听器：多个事件监听器听共同监听同一个监听器时，事件被触发后无法保证这些事件监听器的执行顺序。

定义一个无序的事件监听器：库存服务监听器

/**
 * Created by zhurudong on 2017/10/22.
 */
@Component
public class StockPaymentStatusUpdateListener implements ApplicationListener<PaymentStatusUpdateEvent> {

    @Override
    public void onApplicationEvent(PaymentStatusUpdateEvent event) {
        System.out.println("库存服务, 收到支付状态更新的事件. " + event + " - Thread: " + Thread.currentThread().getName());
    }
}

定义一个有序监听器：邮件服务监听器、库存服务监听器

/**
 * Created by zhurudong on 2017/10/22.
 */
@Component
public class MailPaymentStatusUpdateListener implements SmartApplicationListener {
    @Override
    public boolean supportsEventType(Class eventType) {
        return eventType == PaymentStatusUpdateEvent.class;
    }

    @Override
    public boolean supportsSourceType(Class sourceType) {
        return sourceType == PaymentInfo.class;
    }

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println("邮件服务, 收到支付状态更新的通知. " + event+ " - Thread: " + Thread.currentThread().getName());
    }

    // 排序
    @Override
    public int getOrder() {
        return 1;
    }
}

@Component
public class SmsPaymentStatusUpdateListener implements SmartApplicationListener {
    @Override
    public boolean supportsEventType(Class eventType) {
        return eventType == PaymentStatusUpdateEvent.class;
    }

    @Override
    public boolean supportsSourceType(Class sourceType) {
        return sourceType == PaymentInfo.class;
    }

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println("短信服务, 收到支付状态更新的通知. " + event+ " - Thread: " + Thread.currentThread().getName());
    }

    // 排序
    @Override
    public int getOrder() {
        return 2;
    }
}

上述3个类分别定义了一个无序监听器StockPaymentStatusUpdateListener和两个有序监听器MailPaymentStatusUpdateListener和SmsPaymentStatusUpdateListener。在有序监听器中可以看到xxx#getOrder()获取他们的执行顺序，数字越小执行的优先级越高。也就是当事件被触发后MailPaymentStatusUpdateListener会优于SmsPaymentStatusUpdateListener被执行。

Spring的配置文件如下：

"1.0" encoding="UTF-8"?>
"http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       " default-lazy-init="true">

    package="com.event"/>

测试类：

/**
 * Created by zhurudong on 2017/10/22.
 * Spring事件驱动模型
 */
public class Test {

    public static void main(String[] args) throws InterruptedException {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");

        PaymentService paymentService = applicationContext.getBean(PaymentService.class);

        paymentService.pay(1, "支付成功");
    }

}

执行结果如下：

通过上图我们知道，有序邮件服务和短信服务是有序的事件监听器，并定义了邮件服务优于短信服务先执行。所以程序多次运行后结果都是邮件服务先执行，然后是短信服务。

仔细观察上图展示的结果我们发现，所有的监听器都是在主线程中执行的。这就可能会引发性能问题，我们能否将这些事件监听器放到额外的线程去执行，而不在主线程中执行呢？答案是有的。

很方便Spring为我们提供了2种方式将事件执行放到另外的线程中执行

第一种方式：全局异步
先看看Spring文件是如何配置的

"1.0" encoding="UTF-8"?>
"http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       " default-lazy-init="true">
    package="com.event"/>

    
    "payment-status-update-thread" pool-size="10"/>

    "applicationEventMulticaster" class="org.springframework.context.event.SimpleApplicationEventMulticaster">
        "taskExecutor" ref="payment-status-update-thread"/>
    

定义任务执行器，需要配置SimpleApplicationEventMulticaster#taskExecutor属性，将任务执行器配置

"payment-status-update-thread" pool-size="10"/>

注入到SimpleApplicationEventMulticaster中即可，监听器不需要做任何变动。

需要注意的是实例化SimpleApplicationEventMulticaster时的名称必须为applicationEventMulticaster，是固定的，因为在AbstractApplicationContext类中查找事件触发器是通过定义好的bean的名称查找。

关于SimpleApplicationEventMulticaster更多内容后文会有分析。

public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";

我们来看看执行结果：

使用这种方式开启异步化执行事件，也就是所有的事件监听器执行事件时都会在配置的线程中执行。
Spring还提供了一种比较灵活的方式配置，可以将部分的监听器设置为异步执行

第二种方式：注解式配置异步

采用注解的方式配置，将注解@Async放到ApplicationListener#onApplicationEvent(E event)监听器的实现类上，即可将监听器设置为异步化处理

看看spring配置文件

"1.0" encoding="UTF-8"?>
"http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       " default-lazy-init="true">
    package="com.event"/>

    
    "scheduler"  pool-size="5"/>

    
    "payment-status-update-thread" pool-size="10"/>

    
    "payment-status-update-thread" scheduler="scheduler" proxy-target-class="true"/>

在监听器中的使用

/**
 * Created by zhurudong on 2017/10/22.
 */
@Component
public class StockPaymentStatusUpdateListener implements ApplicationListener<PaymentStatusUpdateEvent> {

    @Async
    @Override
    public void onApplicationEvent(PaymentStatusUpdateEvent event) {
        System.out.println("库存服务, 收到支付状态更新的事件. " + event + " - Thread: " + Thread.currentThread().getName());
    }
}

通过上面的注解@Async便可方便地将事件监听器异步化，没有加这个注解的监听器仍然在发布事件的线程中执行。

我们看看执行的结果：

通过上面的执行结果我们可以知道，邮件服务和短信服务因为没有加@Async注解，看到监听器的执行线程是在发布线程中运行的。而加了@Async注解的库存服务器执行线程是在spring配置文件中配置的执行器

2、原理解析

先来了解下Spring事件驱动模型的接口UML图：

从这个图中我们可以大致的了解Spring事件驱动中的各个组件是如何协同一起完成事件的触发和事件的执行。ApplicationListener作为Spring事件驱动中的监听器基类接口，要想实现一个由Spring驱动的事件监听，可以继承于该类；而ApplicationEventPublisher定义了事件的发布接口，Spring容器ApplicatonContext继承了该类，并实现了如何将是一个事件对象ApplicationEvent发布，并通知到事件监听器。先看分析下面几个比较重要的类：

1. ApplicationEvent: 事件对象，Spring事件驱动模型中的对象源，继承JDK EventObject，通过在发布事件时通过EventObject.source字段携带事件相关的数据。

2. ApplicationListener: 应用监听器，负责监听事件对象是否有发生变化，实现该接口并实现onApplicationEvent方法，完成事件发生变化时的逻辑处理

3. ApplicationEventPublisher: 事件发布器，定义了事件发布规范，只定义了接口，具体的实现交由其他类中实现。Spring提供了SimpleApplicationEventMulticaster实现了广播事件发布器。

理解Spring的事件模型可以从上的类图中，清晰地看到各个组件之间的合作关系，并将合作关系的共性抽象出来，对观察者模式做了抽象。

下文我们会从事件驱动模型的各个构件出发分析Spring的事件驱动模型，包含事件对象、事件源（发布事件者）、事件监听器。

1、 事件（事件对象）

Spring事件驱动模型中，承担事件对象的类是ApplicationEvent，集成JDK提供的事件对象EventObject.

此类为Spring事件中用于扩展的事件对象，所有需要使用事件驱动模型发布的事件都可以继承此类，并将事件对象Object source;传递给事件监听器使用，通过该source可以得到事件源，监听器拿到事件源后便可以处理自己的业务逻辑。

public abstract class ApplicationEvent extends EventObject {

   /** use serialVersionUID from Spring 1.2 for interoperability */
   private static final long serialVersionUID = 7099057708183571937L;

   /** System time when the event happened */
   private final long timestamp;

   public ApplicationEvent(Object source) {
      super(source);
      this.timestamp = System.currentTimeMillis();
   }

   public final long getTimestamp() {
      return this.timestamp;
   }
}

Spring自身的实现中，有很多地方用到了事件它自己定义的事件驱动模型。ApplicationContextEvent就是Spring容器事件的基类。

public abstract class ApplicationContextEvent extends ApplicationEvent {

   public ApplicationContextEvent(ApplicationContext source) {
      super(source);
   }

   public final ApplicationContext getApplicationContext() {
      return (ApplicationContext) getSource();
   }
}

例如Spring中基于ApplicationContextEvent实现的事件如图所示：

ContextStartedEvent：Spring Application容器启动后触发的事件。
ContextStopedEvent：Spring Application容器停止后触发的事件。
ContextClosedEvent：Spring Application容器关闭后触发的事件。
ContextRefreshedEvent：Spring Application容器初始化或者刷新完成后触发的事件。

2、 事件源-发布事件者

有了上面的事件对象后，如何发布事件对象呢？同样，Spring也提供了事件发布器，ApplicationContext继承了ApplicationEventPublisher，也就是说明Application有了事件发布的功能。

public abstract class AbstractApplicationContext extends DefaultResourceLoader
      implements ConfigurableApplicationContext, DisposableBean {

// 省略其他代码
    public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";

    @Override
    public void publishEvent(ApplicationEvent event) {
        publishEvent(event, null);
    }

    @Override
    public void publishEvent(Object event) {
        publishEvent(event, null);
    }      
    protected void publishEvent(Object event, ResolvableType eventType) {
        Assert.notNull(event, "Event must not be null");
        if (logger.isTraceEnabled()) {
            logger.trace("Publishing event in " + getDisplayName() + ": " + event);
        }

        // Decorate event as an ApplicationEvent if necessary
        ApplicationEvent applicationEvent;
        if (event instanceof ApplicationEvent) {
            applicationEvent = (ApplicationEvent) event;
        } else {
            applicationEvent = new PayloadApplicationEvent