---

前言

这篇文章接的是上篇文章Spring源码之事件监听机制（上）来讲，通过理解Spring内部的监听机制，手写一个类似的监听机制框架，再从中抽象出设计模式。

---

一、手写事件监听机制框架

1.准备

JDK为我们提供了事件监听的支持，在java.util包的下面提供了事件监听接口以及事件类。

2.事件监听接口

public interface IEventListener<E extends EventObject> extends EventListener {

    void onApplicationEvent(E event);
}

定义一个事件监听接口供事件监听类实现

3.事件管理器

public class EventMulticaster {

    private Set<IEventListener> set = new LinkedHashSet<>();

    public void registerListener(IEventListener listener) {
        if (!set.contains(listener)) {
            set.add(listener);
        }
    }

    public void removeListener(IEventListener listener) {
        if (!set.contains(listener)) {
            set.remove(listener);
        }
    }

    public Set<IEventListener> getEventListeners() {
        return set;
    }

}

定义一个事件管理器，存储事件监听以及对事件监听的增删操作

4.事件发布器

public class EventPublisher {

    private EventMulticaster eventMulticaster;

    public void initEventMulticaster() {
        if (eventMulticaster == null) {
            eventMulticaster = new EventMulticaster();
        }
    }

    public void registerListener(IEventListener listener) {
        if (eventMulticaster != null) {
            eventMulticaster.registerListener(listener);
        }
    }

    public void removeListener(IEventListener listener) {
        if (eventMulticaster != null) {
            eventMulticaster.removeListener(listener);
        }
    }

    public void publishEvent(EventObject eventObject) {
        if (eventMulticaster != null) {
            Set<IEventListener> set = eventMulticaster.getEventListeners();
            for (IEventListener listener : set) {
                listener.onApplicationEvent(eventObject);
            }
        }
    }
}

5.需求

和上一篇一样：在订单服务中，用户下单成功后，需要物流服务和库存服务进行相应的处理，采取异步解耦的方式。

6.编码

1. 订单事件

public class OrderEvent extends EventObject {

    public OrderEvent(Object source) {
        super(source);
    }
}

2. 库存监听

public class StoreListener implements IEventListener<OrderEvent>{
    @Override
    public void onApplicationEvent(OrderEvent event) {
        System.out.println("库存服务运行中……");
    }
}

3. 物流监听

public class LogisticsListener implements IEventListener<OrderEvent> {
    @Override
    public void onApplicationEvent(OrderEvent event) {
        System.out.println("物流服务运行中……");
    }
}

4. 订单服务

System.out.println("订单服务开始运行");
System.out.println("创建订单完成，通知物流、库存……");
// 初始化事件管理器
EventPublisher eventPublisher = new EventPublisher();
eventPublisher.initEventMulticaster();
// 添加事件监听
eventPublisher.registerListener(new LogisticsListener());
eventPublisher.registerListener(new StoreListener());
// 发布事件
eventPublisher.publishEvent(new OrderEvent(this));

5. 结果

订单服务开始运行
创建订单完成，通知物流、库存……
物流服务运行中……
库存服务运行中……

二、观察者模式

1.概述

观察者模式（有时又被称为模型（Model）-视图（View）模式、源-收听者(Listener)模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。（百度百科）

事件监听机制进行建模分析，当不考虑事件发布器之后，可以简单的理解为：一个事件对应着多个监听者，当事件发布的时候，监听者收到消息，是不是就是典型的观察者模式。

2.UML图

其实JDK已经为我们提供了对观察者模式的支持，下面是我根据JDK中提供的观察者与被观察者绘制的UML图：

从UML图中可以看出：被观察者也被称为主题，与观察者之间是一对多的关系，主题存储着所有观察者，当主题状态变更的时候，通知观察者进行更新。

3.Coding验证

1. 主题

public class Subject extends Observable {

    public void setChanged() {
        super.setChanged();
    }
}

2. 观察者

public class ConcreteObserver1 implements Observer {

    private String name;

    public ConcreteObserver1(String name) {
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {
        System.out.println(name + "：当前状态：" + o.hasChanged() + "，内容：" + arg.toString());
    }
}

3. 客户端验证

public class Client {
    public static void main(String[] args) {
        Subject subject = new Subject();
        subject.addObserver(new ConcreteObserver1("观察者1"));
        subject.addObserver(new ConcreteObserver2("观察者2"));
        subject.setChanged();
        subject.notifyObservers("我已经不是当初你认识的我自己……");
    }
}

4. 结果

观察者2：当前状态：false，内容：我已经不是当初你认识的我自己……
观察者1：当前状态：false，内容：我已经不是当初你认识的我自己……

---

小结

  从Spring的事件监听机制，到自定义监听框架，再到观察者模式，一路走来，从繁入简，相信大家对Spring的监听机制已经有了清晰的认知。
  那我们从设计模式，到Sping的事件监听再回顾一下。当对象之间存在着一对多的关系，一个对象改变，依赖于它的所有对象都会收到通知，这就是我们的观察者模式。但被观察者与观察者之间依然存在着很强的耦合关系，所以为了降低这种耦合关系，我们在被观察者和观察者之间放置一个消息通道，也就是事件发布器，这就是事件监听机制，Spring的事件监听机制就是依托于此，只不过它更加的完善。
  好了，这篇文章到这里就结束了，相信到这里再回头看Spring的事件监听机制源码一定会有不一样的收获。