设计模式：观察者模式（有利于代码解耦）

概念

---

首先，什么是观察者模式：多个观察者去监听主题，当主题发生变化的时候，主题会通知所有的观察者。
盗用网上的一个图：

从上图的结构可以看出，主题维护了一个观察者类型的链表，每当主题变化的时候，就会循环调用各个观察者的对应方法（这就是通知）。
在观察者模式中，又分为 推模型 和 拉模型。

• 推模型：主题向观察者推送详细信息。
• 拉模型：主题把自身作为一个参数发送给观察者，观察者需要什么信息，那么就 主题.getXX() 。

Java中的观察者模式

---

再来看看 Java中的观察者模式，最后再提一下 个人在 SpringBoot 中对于观察者模式的实际使用。

Java 提供了 Observer接口（观察者接口） 和 Observable 接口（被观察者接口 / 主题接口）。源码如下：

Observable 接口（被观察者接口 / 主题接口）：

public class Observable {      private boolean changed = false;      private Vector<Observer> obs;      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) {              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();      }  }  

如上代码：通过 Vector 维护一个 观察者类型的数组。通过调用 notifyObeservers(Object arg) 方法 来通过观察者。在实现中，也是通过for 循环 通知。
Ps：注意：从代码上看，需要先设changed。

Observer接口（观察者接口）：

public interface Observer {      void update(Observable o, Object arg);  } 

这两个参数的含义为：

* @param   o     the observable object.  * @param   arg   an argument passed to the <code>notifyObservers</code>  

所以，此时即实现了 推模型，也实现了 拉模型。如果我们使用，那么分别实现这两个接口即可。

SpringBoot事件机制对于观察者模式的运用

---

那么在个人的实际运用中，做的是一个记账的服务，让别人来调用。当然，可以让别人直接在他们的业务处理后面，例如购买了XX东西，马上就直接调用我的记账服务，但是这样其实是一个紧耦合，由于是两个不同的业务，所以紧耦合感觉不太好。那么 观察者模式就有利于解耦。

对于Spring Boot 的事件机制，同样离不开 这2个东西－主题，观察者。 但是 ，spring boot 把 之前所说的通知，包装成了一个 Event。下面分析这三者。

SpringBoot的主题

Spring boot 的主题 可以 由 ApplicationContext 来充当。ApplicaitonContext 继承于 ApplicationEventPublisher。ApplicaiotnEventPublisher 源码如下：

public interface ApplicationEventPublisher {      /**      * Notify all listeners registered with this application of an application      * event. Events may be framework events (such as RequestHandledEvent)      * or application-specific events.      * @param event the event to publish      * @see org.springframework.web.context.support.RequestHandledEvent      */      void publishEvent(ApplicationEvent event);  }  

其实该接口就是我们 发布事件的接口。

SpringBoot 的观察者

Spring Boot 的观察者由 ApplicationListener 来进行充当。源码如下：

public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {      /**      * Handle an application event.      * @param event the event to respond to      */      void onApplicationEvent(E event);  } 

可以看到， onApplicaiton(E event) 方法即 上文所说的 update 方法。

SpringBoot的Event

上文所说的 主题 和 观察者 都有体现，传输的消息 Spring Boot 使用了一个 ApplicationEvent 进行了封装，源码如下：

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;      }  }  

EventObject 源码：

public class EventObject implements java.io.Serializable {      private static final long serialVersionUID = 5516075349620653480L;      /**      * The object on which the Event initially occurred.      */      protected transient Object  source;      public EventObject(Object source) {          if (source == null)              throw new IllegalArgumentException("null source");          this.source = source;      }      public Object getSource() {          return source;      }      public String toString() {          return getClass().getName() + "[source=" + source + "]";      }  }  

由上面的代码 可知，其实 ApplicationEvent 就是 把需要传输的消息 封装起来。这个消息并没有想 Java 的实现那样推拉模型都实现了，而是 只实现了 拉模型 。

最后，我们程序中只需要 注入ApplicaitonContext 发送消息，实现 ApplicationListener 接口进行相应的处理即可。

总结

---

观察者模式实质是 有两个 东西：

• 一个是 主题
• 一个是观察者

主题中维护了 观察者列表的引用。当主题有变更的时候，循环调用观察者，通知其做相应的处理。另外，不论是 Java，还是 Spring ，都是利用这个原理，只是有不同的类充当 主题 和 观察者。
另外，观察者模式有一个好处：解耦。