观察者(Observer)模式
观察者模式又叫做发布-订阅模式(Publish.Subscribe)模式、模型-视图模式(Model/View)模式、源-监听器模式(Source/Listener)模式或从属者(Dependents)模式。
观察者模式定义了一种一对多的依赖关系,让多个观察者同时监听某一个主题对象。这个主题对象在状态上发生变化时,会通知所有观察者对象,使它们能够自动更新自己。
1. 观察者模式结构
一个简单的观察者模型如下:
角色:
抽象(Subject)主题角色:把所有的观察者维持在一个集合中,每个主题都可以有任意数量的观察者。提供一个接口,可以增加和删除观察者,主题角色又叫做被观察者(Observable)。
抽象观察者(Observer)角色:在得到主题的通知时更新自己。有时候观察者依赖于被观察者,可以将update方法修改为 void update(Subject subject)。
具体主题角色:维护所有的观察者,在具体主题的内部状态改变时给所有登记的观察者发送通知。
具体观察者角色:存储与主题的状态自恰的状态,也就是随着主题的状态改变自己的状态。
代码如下:
package cn.qlq.observer; public interface Subject {
void attach(Observer observer); void delete(Observer observer); void notifyObservers();
}
package cn.qlq.observer; import java.util.Enumeration;
import java.util.List;
import java.util.Vector; public class ConcreteSubject implements Subject { private List<Observer> observers = new Vector<>(); @Override
public void attach(Observer observer) {
observers.add(observer);
} @Override
public void delete(Observer observer) {
observers.remove(observer);
} @Override
public void notifyObservers() {
for (Observer observer : observers) {
observer.update();
}
} }
package cn.qlq.observer; public interface Observer { /**
*
*/
void update(); }
package cn.qlq.observer; public class ConcreteObserver implements Observer { @Override
public void update() {
System.out.println(" i am notified");
} }
2. 第二种实现
考虑上面的主题中,管理维护观察者集合的方法可以放到抽象类中去实现,因此可以将维护观察者关系的代码抽取到抽象类中,类图如下:
这种方式与上面的区别是代表存储观察者对象的集合从连线是从抽象主题到抽象观察者。(也就是抽象主体维护抽象观察者的引用关系)
代码如下:
package cn.qlq.observer; import java.util.List;
import java.util.Vector; public abstract class Subject {
private List<Observer> observers = new Vector<>(); public void attach(Observer observer) {
observers.add(observer);
} public void delete(Observer observer) {
observers.remove(observer);
} public void notifyObservers() {
for (Observer observer : observers) {
observer.update();
}
}
}
package cn.qlq.observer; public class ConcreteSubject extends Subject { private String state; public void changeState(String newState) {
state = newState;
this.notifyObservers();
} }
package cn.qlq.observer; public interface Observer { /**
*
*/
void update(); }
package cn.qlq.observer; public class ConcreteObserver implements Observer { @Override
public void update() {
System.out.println(" i am notified");
} }
客户端测试代码:
package cn.qlq.observer; public class Client { public static void main(String[] args) {
ConcreteSubject subject = new ConcreteSubject();
Observer observer = new ConcreteObserver(); subject.attach(observer); subject.changeState("1");
} }
3. Java语言对观察者模式的支持
在Java.util保重中,提供了一个Observable类以及一个Observer接口。
Observer接口: 此接口只定义了一个update方法,当被观察者的状态发生变化时被观察者对象的notifyOeservers()方法会调用这一方法。
public interface Observer { void update(Observable o, Object arg);
}
Observable类:被观察者类都是该类的子类,该类有两个重要的方法:
setChanged(): 设置一个内部标记标记其状态发生变化
notifyObsers(): 这个方法被调用时会调用所有注册的观察者的update()方法。
package java.util; public class Observable {
private boolean changed = false;
private Vector 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();
}
}
简单的使用Java对观察者模式的支持:
package cn.qlq.observer; import java.util.Observable; public class Watched extends Observable { private String data = ""; public String getData() {
return data;
} public void changeData(String data) {
if (!this.data.equals(data)) {
this.data = data;
setChanged();
} notifyObservers();
} }
package cn.qlq.observer; import java.util.Observable;
import java.util.Observer; public class Watcher implements Observer { @Override
public void update(Observable o, Object arg) {
if (o != null && (o instanceof Watched)) {
Watched watched = (Watched) o;
System.out.println("data changed to: " + watched.getData());
}
} }
客户端代码
package cn.qlq.observer; public class Client { public static void main(String[] args) {
Watched watched = new Watched();
Watcher watcher = new Watcher(); watched.addObserver(watcher); watched.changeData("123");
watched.changeData("123");
watched.changeData("456");
watched.changeData("789");
}
}
结果:(虽然改变了四次值,但是有两次一样,查看源码啊在notifyObsers()中会清掉changed的值)
data changed to: 123
data changed to: 456
data changed to: 789
4. 观察者模式优缺点
优点:
(1)观察者模式在被观察者和观察者直接建立一个抽象的耦合
(2)观察者模式支持广播通信。被观察者会向所有登记的观察者发出通知。
缺点:
(1)如果被观察者的观察者过多,通知所有观察者需要花费很多时间
(2)如果在被观察者之间有循环依赖容易循环调用
(3)如果对观察者的通知是通过多线程通知必须保证通知的正确性
(4)观察者可以知道观察者状态发生了变化,不知道是怎么发生变化的。
总结:
意图:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。
主要解决:一个对象状态改变给其他对象通知的问题,而且要考虑到易用和低耦合,保证高度的协作。
何时使用:一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知,进行广播通知。
如何解决:使用面向对象技术,可以将这种依赖关系弱化。
关键代码:在抽象类里有一个 ArrayList 存放观察者们。
应用实例: 1、拍卖的时候,拍卖师观察最高标价,然后通知给其他竞价者竞价。 2、西游记里面悟空请求菩萨降服红孩儿,菩萨洒了一地水招来一个老乌龟,这个乌龟就是观察者,他观察菩萨洒水这个动作。
优点: 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。
缺点: 1、如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的,而仅仅只是知道观察目标发生了变化。
注意事项: 1、JAVA 中已经有了对观察者模式的支持类。 2、避免循环引用。 3、如果顺序执行,某一观察者错误会导致系统卡壳,一般采用异步方式。
观察者(Observer)模式的更多相关文章
- Java 实现观察者(Observer)模式
1. Java自带的实现 类图 /** * 观察目标 继承自 java.util.Observable * @author stone * */ public class UpdateObservab ...
- 设计模式C++描述----04.观察者(Observer)模式
一. 概述 Observer 模式要解决的问题为:建立一个一(Subject)对多(Observer)的依赖关系,并且做到当“一”变化的时候,依赖这个“一”的多也能够同步改变. Sbuject 相当于 ...
- Java设计模式之从[星际争霸的兵种升级]分析观察者(Observer)模式
观察者模式定义对象的一种一对多的依赖关系.当一个对象的状态发生改变时.全部依赖于它的对象都会得到通知并被自己主动更新. 一个简单的样例是.在星际争霸的虫族中有一个0基础单位叫做跳狗(Zergling) ...
- 面向对象设计模式——观察者(OBSERVER)模式
定义 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新. Observer模式描述了如何建立这种关系.这一模式中的关键对象是目标(subject ...
- 设计模式之观察者(OBSERVER)模式
定义 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新. Observer模式描述了如何建立这种关系.这一模式中的关键对象是目标(subject ...
- java观察者(Observer)模式
观察者模式: 试想,在电子商务网站上,一个用户看中了一件一份,但是当时衣服的价格太贵,你需要将衣服收藏,以便等衣服降价时自动通知该用户.这里就是典型的观察模式的例子. 1.观察者模式的 ...
- Head First 设计模式 —— 02. 观察者 (Observer) 模式
思考题 在我们的一个实现中,下列哪种说法正确?(多选) P42 public class WeatherDate { // 实例变量声明 public void measurementsChanged ...
- 《Head First 设计模式》ch.2 观察者(Observer)模式
观察者模式 定义了对象之间一对多以来,这样一来,当一个对象改变状态时,它所有的依赖者都会收到通知并自动更新 设计原则-松耦合 松耦合将对象之间的互相依赖降到了最低——只要他们之间的接口仍被遵守 观察者 ...
- Observer(观察者)模式
1.概述 一些面向对象的编程方式,提供了一种构建对象间复杂网络互连的能力.当对象们连接在一起时,它们就可以相互提供服务和信息. 通常来说,当某个对象的状态发生改变时,你仍然需要对象之间能互相通信.但是 ...
随机推荐
- 秋招打怪升级之路:十面阿里,终获offer!
本文转载自:https://gongfukangee.github.io/2019/09/06/Job/ 作者:G.Fukang 开源项目推荐: JavaGuide: Java学习+面试指南!Gith ...
- iOS编程
一.语法 1. performSelector 2.
- H5新增form控件和表单属性
第一个知识点:表单的属性及总结 第二个知识点:H5新增的表单控件和属性以及总结 第一个知识点: 我们常见的表单验证有哪些呢 text 文本框标签 password 密码框 checkbox 多选框 r ...
- 基于Netty的IdleStateHandler实现Mqtt心跳
基于Netty的IdleStateHandler实现Mqtt心跳 IdleStateHandler解析 最近研究jetlinks编写的基于Netty的mqtt-client(https://githu ...
- 【学习笔记】PYTHON语言程序设计(北理工 嵩天)
1 Python基本语法元素 1.1 程序设计基本方法 计算机发展历史上最重要的预测法则 摩尔定律:单位面积集成电路上可容纳晶体管数量约2年翻倍 cpu/gpu.内存.硬盘.电子产品价格等都遵 ...
- html5表单上传控件Files筛选指定格式的文件:accept属性过滤excel文件
摘自:http://blog.csdn.net/jyy_12/article/details/9851349 (IE9及以下不支持下面这些功能,其它浏览器最新版本均已支持.) 1.允许上传文件数量 允 ...
- window配合虚拟机VMware搭建虚拟ubuntu服务器入坑集锦
1.VMware虚拟机和主机进行网络连接设置 https://jingyan.baidu.com/article/adc81513b86621f723bf7383.html 2.解决linux虚拟机与 ...
- 国内不fq安装K8S四: 安装过程中遇到的问题和解决方法
目录 4 安装过程中遇到的问题和解决方法 4.1 常见问题 4.2 常用的操作命令 4.3 比较好的博客 国内不fq安装K8S一: 安装docker 国内不fq安装K8S二: 安装kubernet 国 ...
- php静态化介绍
1.动态URL地址设置成静态形式http://state.com/index.php?c=play&a=index&id=16267 ------>http://state.co ...
- Docker安装Redis4.0
docker pull redis:4.0 拉取Redis4.0镜像 docker images 查看本地的镜像 mkdir -p /root/redis4.0/data 在宿主机创建数据文件目录 w ...