观察者模式 (Observer Pattern) 是一种行为型设计模式,又被称为发布-订阅 (Publish/Subscribe) 模式,它定义了对象之间的一种一对多的依赖关系,使得当一个对象的状态发生变化时,所有依赖于它的对象都会自动收到通知并更新。
在观察者模式中有如下角色:
Observer
角色。Subject
角色的状态变化的通知,为此,它声明了 update
方法。update
方法被调用后,会去获取要观察的对象的最新状态。【例】微信公众号。在使用微信公众号时,大家都会有这样的体验,当你关注的公众号中有新内容更新的话,它就会推送给关注公众号的微信用户端。我们使用观察者模式来模拟这样的场景,微信用户就是观察者,微信公众号是观察对象,有多个的微信用户关注了程序猿这个公众号。 具体类图如下:
具体实现代码如下:
Observer.java
public interface Observer {
void update(String message);
}
Subject.java
//观察对象
public interface Subject {
//添加订阅者(观察者对象)
void attach(Observer observer);
//删除订阅者
void detach(Observer observer);
//通知订阅者更新消息
void notify(String message);
}
WeiXinObserver.java
//具体的观察者角色类
public class WeiXinObserver implements Observer{
private String name;
public WeiXinObserver(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + " : " + message);
}
}
SubscriptionSubject.java
import java.util.ArrayList;
import java.util.List;
//具体主题角色类
public class SubscriptionSubject implements Subject{
//定义一个集合,用来存储多个观察者对象
private List<Observer> weiXinUserList = new ArrayList<>();
@Override
public void attach(Observer observer) {
weiXinUserList.add(observer);
}
@Override
public void detach(Observer observer) {
weiXinUserList.remove(observer);
}
@Override
public void notify(String message) {
//遍历集合
for (Observer observer : weiXinUserList) {
//调用观察者对象中的 update 方法
observer.update(message);
}
}
}
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专栏更新了!");
}
}
(1)优点
(2)缺点
(1)观察者模式适用于以下场景:
(2)总之,观察者模式适用于需要一对多的依赖关系,并且对观察者和被观察者之间的耦合度要求较低的场景。它常用于发布-订阅模型、UI 事件处理、实时数据更新、消息队列系统、MVC 架构等应用场景。
在 Java 中,通过 java.util.Observable 类和 java.util.Observer 接口定义了观察者模式,只要实现它们的子类就可以编写观察者模式实例。
其源码如下:
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();
}
}
Observer 接口是抽象观察者,它监视目标对象的变化,当目标对象发生变化时,观察者得到通知,并调用 update() 方法,进行相应的工作。其源码如下:
package java.util;
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);
}
【例】警察抓小偷。警察抓小偷也可以使用观察者模式来实现,警察是观察者,小偷是被观察者。代码如下:
(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 = true
super.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;
}
@Override
public 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();
}
}
结果如下:
小偷:我偷东西了,有没有人来抓我!!!
警察:小偷,我已经盯你很久了,你可以保持沉默,但你所说的将成为呈堂证供!!!