EventBus—思考观察者模式与发布订阅者模式_PPLLiang的博客

2. 观察者模式

2.1. 观察者模式UML类图

观察者模式有以上两种实现：一种将被观察者方法抽象出来，一种直接创建被观察者对象，两者只是将观察者逻辑抽象出来而已，并没有很大的不同之处。以图一讲述观察者模式，其包含四个角色：
Observerable：被观察者抽象接口，提供注册和解注册以及通知观察者的抽象方法；
ConcreteObserverable：具体被观察者对象，维护了一个观察者集合对象并实现所需的通知观察者的接口；
Observer：观察者抽象接口，定义更新观察者自己的更新方法；
ConcreteObserver：具体的观察者对象，实现更新的业务逻辑；
2.2. 具体例子

定义被观察者抽象接口
public interface Observerable {
    void regiseted(Observer observer);
    void unregiseted(Observer observer);
    void notifyObserver();
定义具体被观察者对象 
public class ConcreteObserverable implements Observerable{
    private ArrayList<Observer> mObservers = new ArrayList<>();
    @Override
    public void regiseted(Observer observer) {
        mObservers.add(observer);
    @Override
    public void unregiseted(Observer observer) {
        if (mObservers.contains(observer)) {
            mObservers.remove(observer);
    @Override
    public void notifyObserver() {
        for (Observer observer : mObservers) {
            observer.update();
    public void updateState(){
        Log.i("wuzl", "update state , the state has changed.");
        notifyObserver();
定义观察者抽象接口 
public interface Observer {
    void update();
定义具体观察者对象：ObserverA，ObserverB，ObserverC 
public class ObserverA implements Observer {
    @Override
    public void update() {
        Log.i("wuzl", "Observer A receives the update event");
public class ObserverB implements Observer {
    @Override
    public void update() {
        Log.i("wuzl", "Observer B receives the update event");
public class ObserverC implements Observer {
    @Override
    public void update() {
        Log.i("wuzl", "Observer C receives the update event");
客户端调用： 
    public void verifyObserverPattern(){
        Observer observerA = new ObserverA();
        Observer observerB = new ObserverB();
        Observer observerC = new ObserverC();
        ConcreteObserverable observerable = new ConcreteObserverable();
        observerable.regiseted(observerA);
        observerable.regiseted(observerB);
        observerable.regiseted(observerC);
        observerable.updateState();
wuzl: update state , the state has changed.
wuzl: Observer A receives the update event
wuzl: Observer B receives the update event
wuzl: Observer C receives the update event
（以上代码均为测试验证代码，非实际开发代码） 
2.3. 小结
 
观察者模式很好地解耦对象间一对多的关系，并且建立起一套触发更新的机制。但是通过上面的例子发现，被观察者（ConcreteObserverable）的对象太重了，既要维护观察者的列表，又要处理消息通知（既当爹又当妈），这违背设计模式中单一职责模式，一旦业务逻辑复杂起来将会酿成灾难呀。同时如果有多个被观察者类（ConcreteObserverable），每个被观察者触发更新逻辑基本一致，重复实现造成大量冗余的垃圾代码。
 那么发布订阅者模式应运而生，将观察者的维护、消息处理逻辑剥离出来构建一个调用中心，通过构建事件触发观察者的更新。 
3. 发布订阅者模式
 
讲述发布订阅者模式前，先看看EventBus官网的结构图：
 
 其结构图就是发布订阅者模式的结构图。 
3.1. 发布订阅者模式UML图
 

 该模式有五个角色： 
Publisher：发布者，发布事件告知调度中心“事件更新了”；
Dispatcher：调度中心，类似观察者模式中“被观察者”的功能，维护事件与订阅者的映射关系列表，以及处理订阅、发布等逻辑事件，一般单例对象；
Event：事件对象；
Subscriber：订阅者，与观察者模式的抽象观察者一致；
ConcreteSubscriber：具体的订阅者，与观察者模式的观察者一致； 
3.2. 具体例子
 
构建调度中心（Dispatcher）：单例+subscriptionByEventType映射表格+typesBySubscriber映射表格。
 subscriptionByEventType：存储了订阅者与事件的映射关系表（一个订阅者可以订阅多个事件）；
 typesBySubscriber：存储了事件与订阅者的映射关系表（一个事件可以对应多个订阅者） 
public class Dispatcher {
    private static Dispatcher mInstance;
    private Dispatcher(){}
    public static Dispatcher getInstance(){
        if (mInstance == null) {
            synchronized (Dispatcher.class) {
                if (mInstance == null) {
                    mInstance = new Dispatcher();
        return mInstance;
    private HashMap<Class<?>, List<Subscriber>> subscriptionByEventType = new HashMap<Class<?>, List<Subscriber>>();
    private HashMap<Subscriber, List<Class<?>>> typesBySubscriber = new HashMap<Subscriber, List<Class<?>>>();
    public void registered(Subscriber subscriber, Class event) {
        List<Subscriber> subscribers;
        if (!subscriptionByEventType.containsKey(event)) {
            subscribers = new ArrayList<Subscriber>();
        } else {
            subscribers = subscriptionByEventType.get(event);
        subscribers.add(subscriber);
        subscriptionByEventType.put(event, subscribers);
    public void unregistered(Subscriber subscriber) {
        List<Class<?>> classes = typesBySubscriber.get(subscriber);
        if (classes == null) {
            return;
        for (Class event : classes) {
            if (subscriptionByEventType.containsKey(event)) {
                subscriptionByEventType.remove(event);
    public void post(Class event) {
        List<Subscriber> subscribers = subscriptionByEventType.get(event);
        if (subscribers != null && !subscribers.isEmpty()) {
            for (Subscriber subscriber : subscribers) {
                subscriber.onEvent();
构建订阅者抽象类 
public interface Subscriber {
    void onEvent();
具体的抽象类 
public class SubscriberA implements Subscriber {
    @Override
    public void onEvent() {
        Log.i("wuzl", "SubscriberA onEvent");
public class SubscriberB implements Subscriber {
    @Override
    public void onEvent() {
        Log.i("wuzl", "SubscriberB onEvent");
public class SubscriberC implements Subscriber {
    @Override
    public void onEvent() {
        Log.i("wuzl", "SubscriberC onEvent");
发布者与事件 
public class Publisher {
    public void publishNewEvent(){
        Log.i("wuzl", "publishNewEvent");
        Dispatcher.getInstance().post(NewEvent.class);
    public void verifyPublisherPattern(){
        Subscriber subscriberA = new SubscriberA();
        Subscriber subscriberB = new SubscriberB();
        Subscriber subscriberC = new SubscriberC();
        Dispatcher.getInstance().registered(subscriberA, NewEvent.class);
        Dispatcher.getInstance().registered(subscriberB, NewEvent.class);
        Dispatcher.getInstance().registered(subscriberC, NewEvent.class);
        publishNewEvent();
public class NewEvent {
wuzl: publishNewEvent
wuzl：SubscriberA onEvent
wuzl：SubscriberB onEvent
wuzl：SubscriberC onEvent
3.3. 小结
 
我大大简化了发布订阅者模式的代码，方便例子输出，EventBus中的实现更加的人性化与解耦性更好，详情可查看EventBus—源码解析。
 从上面的发布订阅者模式的例子，调度中心维护了观察者事件列表、消息处理逻辑，职责更加单一并且逻辑更加清楚，然后通过事件驱动整个订阅模式的流转。 
4. 总结
 
观察者模式和发布订阅者模式都是用于处理对象间一对多的关系；
两个模式都是为了解耦代码、建立一套更新机制;
观察者模式中被观察者对象背负了过重的逻辑：观察者列表和消息处理；
订阅发布者模式剥离出单例的调用中心，以事件作为驱动；
                    EventBus系列文章：EventBus—使用实践EventBus—源码解析1. 概述在EventBus的学习当中，EventBus是基于发布订阅者模式的消息处理框架。EventBus is an open-source library for Android and Java using the publisher/subscriber pattern for loose co...
				EventBus是Android下高效的发布/订阅事件总线机制。作用是可以代替传统的Intent,Handler,Broadcast或接口函数在Fragment,Activity,Service,线程之间传递数据，执行方法。特点是代码简洁，是一种发布订阅设计模式（Publish/Subsribe），或称作观察者设计模式。
文章地址：http://blog.csdn.net/kpioneer123/article/details/51303995
				观察者模式和事件通知备忘
MessageBus.instance().post(Notify.PARKIN, in,bytes); 
这种是仿照Android的EventBus，用new的一个实例对象根据path反射调用其中的方法处理逻辑 
要修改为 rest形式，根据path指定类的方法，然后每次反射new一个新的对象处理逻辑 
这种适合消息通知，广播事件
ListenerBus 是把path或者
				原文：https://www.cnblogs.com/whitewolf/p/4132840.html
Guava在guava-libraries中为我们提供了事件总线EventBus库，它是事件发布订阅模式的实现，让我们能在领域驱动设计(DDD)中以事件的弱引用本质对我们的模块和领域边界很好的解耦设计。
不再多的废话，直奔Guava EventBus主题。首先Guava为我们提供了同步事件E...
简单的程序，不许要考虑通信问题，在一个进程中函数调用即可满足程序功能的分治工作，
但是当程序规模达到一定程序之后， 就必须将程序划分为独立的逻辑体， 逻辑体之间需要进行通信。
本文列举程序通信方式，从微观到宏观。
通过事件，可以将单线程的程序，做好逻辑切分的情况下，产生通信过程，同时保持逻辑解耦。
JS - DOM标准
https://developer.mozilla....
				一,什么是事件总线纷发?
事件纷发是指将事件放入队列,用于管理和纷发;它能保证应用各部件之间高效的通信以及数据,事件的纷发,可以使各模块之间高内聚,低耦合,用于模块间解耦
二,EventBus介绍
Event Bus是一个发布 /订阅的事件总线。 Event Bus模式 —也被称为MessageBus或者发布者/订阅者(publisher/subscriber)模式 —可以让两个组件相互通信
在大规模的软件开发过程中，对象很多，关联关系非常复杂，如果没有统一的、简洁的方法去管理这些对象关系，会导致对象关系复杂，后期维护困难。
基于消息总线技术可以解决这些问题。对象之间只通过消息联系，不是通过直接的依赖或者关联。在消息总线中，对象是通过消息来联系，消息即是对象的关系，只需要在消息总线中管理这些消息，不用关心具体哪些对象之间有关联，便于统一管理。
二、消息总线包含的内容
通用的消息定义
定义一种通用的消息格式，让所有的对象都能接受。
通用的消息类型完整的定义是主题+泛
				React 组件之间的通信可以使用发布-订阅者模式。这种模式提供了一种不直接对组件进行交互的方法。
在发布-订阅者模式中，组件之间不直接交互，而是通过一个中间的订阅者（也称为事件总线）进行通信。
以下是一个简单的例子：
// 创建一个事件总线
const EventBus = new EventEmitter();
// 组件 A 发布消息
function handleClick() {
  EventBus.emit("message", "Hello from A");
function ComponentA() {
  return (
    <button onClick={handleClick}>
    </button>
// 组件 B 订阅消息
function ComponentB() {
  const [message, setMessage] = useState("");
  useEffect(() => {
    EventBus.on("message", setMessage);
    return () => {
      EventBus.off("message", setMessage);
  }, []);
  return <div>收到消息：{message}</div>;
function App() {
  return (
      <ComponentA />
      <ComponentB />
在这个例子中，组件 A 发布一条消息，组件 B 订阅并显示消息。