1.概述

观察者模式 (Observer Pattern) 是一种行为型设计模式，又被称为发布-订阅 (Publish/Subscribe) 模式，它定义了对象之间的一种一对多的依赖关系，使得当一个对象的状态发生变化时，所有依赖于它的对象都会自动收到通知并更新。

2.结构

在观察者模式中有如下角色：

• Subject：观察对象，定义了注册观察者和删除观察者的方法。此外，它还声明了“获取现在的状态”的方法。
• ConcreteSubject：具体观察对象，当自身状态发生变化后，它会通知所有已经注册的 Observer 角色。
• Observer：抽象观察者，负责接收来自 Subject 角色的状态变化的通知，为此，它声明了 update 方法。
• ConcrereObserver：具体观察者，当它的 update 方法被调用后，会去获取要观察的对象的最新状态。

3.案例实现

【例】微信公众号。在使用微信公众号时，大家都会有这样的体验，当你关注的公众号中有新内容更新的话，它就会推送给关注公众号的微信用户端。我们使用观察者模式来模拟这样的场景，微信用户就是观察者，微信公众号是观察对象，有多个的微信用户关注了程序猿这个公众号。 具体类图如下：

具体实现代码如下：

3.1.抽象观察者

Observer.java

public interface Observer {void update(String message);
}

3.2.观察对象

Subject.java

//观察对象
public interface Subject {//添加订阅者(观察者对象)void attach(Observer observer);//删除订阅者void detach(Observer observer);//通知订阅者更新消息void notify(String message);
}

3.3.具体观察者

WeiXinObserver.java

//具体的观察者角色类
public class WeiXinObserver implements Observer{private String name;public WeiXinObserver(String name) {this.name = name;}@Overridepublic void update(String message) {System.out.println(name + " : " + message);}
}

3.4.具体观察对象

SubscriptionSubject.java

import java.util.ArrayList;
import java.util.List;//具体主题角色类
public class SubscriptionSubject implements Subject{//定义一个集合，用来存储多个观察者对象private List<Observer> weiXinUserList = new ArrayList<>();@Overridepublic void attach(Observer observer) {weiXinUserList.add(observer);}@Overridepublic void detach(Observer observer) {weiXinUserList.remove(observer);}@Overridepublic void notify(String message) {//遍历集合for (Observer observer : weiXinUserList) {//调用观察者对象中的 update 方法observer.update(message);}}
}

3.5.测试

Client.java

public class Client {public static void main(String[] args) {//1.创建公众号对象SubscriptionSubject subject = new SubscriptionSubject();//2.订阅公众号subject.attach(new WeiXinObserver("Tom"));subject.attach(new WeiXinObserver("Mike"));subject.attach(new WeiXinObserver("Jerry"));//3.公众号更新subject.notify("Java专栏更新了！");}
}

4.优缺点

（1）优点

• 解耦性：观察者模式将观察者和主题（被观察者）解耦，使得它们之间的依赖关系变得松散。主题只需要知道观察者的抽象接口，而不需要知道具体的观察者对象。
• 可扩展性：通过新增或删除观察者，可以方便地扩展系统的功能。主题可以随时添加或删除观察者，而不会影响到其他部分的代码。
• 广播通信：主题通知所有的观察者对象，实现事件的广播通信，方便多个对象对事件做出响应。
• 符合开闭原则：新增观察者时无需修改主题的代码，只需实现新的观察者接口即可，符合开闭原则的要求。

（2）缺点

• 观察者过多可能导致性能问题：如果观察者过多，或者通知频繁，可能会导致系统性能下降。因此在设计时需注意对观察者的控制。
• 观察者和主题关系不明确：观察者模式中的观察者和主题之间的关系是松散的，观察者无法准确知道有哪些其他观察者存在。可能存在一些潜在的问题和维护的困难。

5.使用场景

（1）观察者模式适用于以下场景：

• 发布-订阅模型：当存在一个主题（或发布者）需要通知多个观察者（或订阅者）并进行相应的处理时，可以使用观察者模式。例如，新闻发布机构将新闻发布给多个订阅者。
• UI 事件处理：在图形用户界面 (GUI) 开发中，观察者模式常用于处理用户界面上的事件。用户操作（如按钮点击、文本框输入等）可以作为主题，而界面元素的更新则可以作为观察者来处理。
• 实时数据更新：当需要将实时数据的更新通知给多个组件或模块时，可以使用观察者模式。例如，股票交易系统中，股票价格的变化可以作为主题，而界面上的多个组件可以作为观察者。
• 消息队列系统：在消息队列系统中，观察者模式可以用于消息的发布和订阅的机制。生产者发布消息到主题中，而消费者作为观察者订阅主题，在消息到达时进行相应的处理。
• MVC 架构：观察者模式常用于应用程序的 MVC（模型-视图-控制器）架构中，用于实现模型与视图之间的通信。当模型的状态发生变化时，观察者模式可以通知相关的视图来刷新界面。
• 多线程编程中的消息通知：在多线程编程中，观察者模式可以用于实现线程间的消息通知机制。一个线程可以作为主题，而其他线程可以作为观察者，通过观察者模式实现线程间的协同工作。

（2）总之，观察者模式适用于需要一对多的依赖关系，并且对观察者和被观察者之间的耦合度要求较低的场景。它常用于发布-订阅模型、UI 事件处理、实时数据更新、消息队列系统、MVC 架构等应用场景。

6.JDK 源码解析——Observable / Observer

在 Java 中，通过 java.util.Observable 类和 java.util.Observer 接口定义了观察者模式，只要实现它们的子类就可以编写观察者模式实例。

6.1.Observable 类

其源码如下：

package java.util;public class Observable {/*changed 为一个 boolean 类型的内部标志，注明目标对象是否发生了变化当它为 true 时，notifyObservers() 才会通知观察者*/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();}
}

6.2.Observer 接口

Observer 接口是抽象观察者，它监视目标对象的变化，当目标对象发生变化时，观察者得到通知，并调用 update() 方法，进行相应的工作。其源码如下：

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

6.3.案例

【例】警察抓小偷。警察抓小偷也可以使用观察者模式来实现，警察是观察者，小偷是被观察者。代码如下：

（1）小偷是一个被观察者，所以需要继承 Observable 类

import java.util.Observable;public class Thief extends Observable {private String name; public Thief(String name) {this.name = name;}public void setName(String name) {this.name = name;}public String getName() {return name;}public void steal() {System.out.println("小偷：我偷东西了，有没有人来抓我！！！");super.setChanged();  //即令changed = truesuper.notifyObservers();}
}

（2）警察是一个观察者，所以需要让其实现 Observer 接口

import java.util.Observable;
import java.util.Observer;public class Policemen implements Observer {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public Policemen(String name) {this.name = name;}@Overridepublic void update(Observable o, Object arg) {System.out.println("警察：" + ((Thief) o).getName() + "，我已经盯你很久了，你可以保持沉默，但你所说的将成为呈堂证供！！！");}
}

public class Client {public static void main(String[] args) {//创建小偷对象Thief t = new Thief("小偷");//创建警察对象Policemen p = new Policemen("小李");//让警察盯着小偷t.addObserver(p);//小偷偷东西t.steal();}
}

结果如下：

小偷：我偷东西了，有没有人来抓我！！！
警察：小偷，我已经盯你很久了，你可以保持沉默，但你所说的将成为呈堂证供！！！