观察者模式
观察者模式是一种行为型设计模式,它定义了一种一对多的依赖关系,当一个对象的状态发生改变时,其所有依赖者都会收到通知并自动更新。
当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知依赖它的对象。观察者模式属于行为型模式。
介绍
意图
创建了对象间的一种一对多的依赖关系,当一个对象状态改变时,所有依赖于它的对象都会得到通知并自动更新。。
主要解决的问题
- 观察者模式解决的是一个对象状态改变时,如何自动通知其他依赖对象的问题,同时保持对象间的低耦合和高协作性。
使用场景
- 当一个对象的状态变化需要同时更新其他对象时。
实现方式
- 定义观察者接口:包含一个更新方法。
- 创建具体观察者:实现观察者接口,定义接收到通知时的行为。
- 定义主题接口:包含添加、删除和通知观察者的方法。
- 创建具体主题:实现主题接口,管理观察者列表,并在状态改变时通知它们。
关键代码
- 观察者列表:在主题中维护一个观察者列表。
应用实例
- 拍卖系统:拍卖师作为主题,竞价者作为观察者,拍卖价格更新时通知所有竞价者。
- 西游记故事:菩萨洒水作为状态改变,老乌龟作为观察者,观察到这一变化。
优点
- 抽象耦合:观察者和主题之间是抽象耦合的。
- 触发机制:建立了一套状态改变时的触发和通知机制。
缺点
- 性能问题:如果观察者众多,通知过程可能耗时。
- 循环依赖:可能导致循环调用和系统崩溃。
- 缺乏变化详情:观察者不知道主题如何变化,只知道变化发生。
使用建议
- 在需要降低对象间耦合度,并且对象状态变化需要触发其他对象变化时使用。
- 考虑使用Java内置的观察者模式支持类,如
java.util.Observable
和java.util.Observer
。
注意事项
- 避免循环引用:注意观察者和主题之间的依赖关系,避免循环引用。
- 异步执行:考虑使用异步通知避免单点故障导致整个系统卡壳。
结构
观察者模式包含以下几个核心角色:
- 主题(Subject):也称为被观察者或可观察者,它是具有状态的对象,并维护着一个观察者列表。主题提供了添加、删除和通知观察者的方法。
- 观察者(Observer):观察者是接收主题通知的对象。观察者需要实现一个更新方法,当收到主题的通知时,调用该方法进行更新操作。
- 具体主题(Concrete Subject):具体主题是主题的具体实现类。它维护着观察者列表,并在状态发生改变时通知观察者。
- 具体观察者(Concrete Observer):具体观察者是观察者的具体实现类。它实现了更新方法,定义了在收到主题通知时需要执行的具体操作。
观察者模式通过将主题和观察者解耦,实现了对象之间的松耦合。当主题的状态发生改变时,所有依赖于它的观察者都会收到通知并进行相应的更新。
实现
观察者模式使用三个类 Subject、Observer 和 Client。Subject 对象带有绑定观察者到 Client 对象和从 Client 对象解绑观察者的方法。我们创建 Subject 类、Observer 抽象类和扩展了抽象类 Observer 的实体类。
ObserverPatternDemo,我们的演示类使用 Subject 和实体类对象来演示观察者模式。
步骤 1
创建 Subject 类。
Subject.java
import java.util.ArrayList;
import java.util.List;
public class Subject {
private List<Observer> observers
= new ArrayList<Observer>();
private int state;
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
notifyAllObservers();
}
public void attach(Observer observer){
observers.add(observer);
}
public void notifyAllObservers(){
for (Observer observer : observers) {
observer.update();
}
}
}
步骤 2
创建 Observer 类。
Observer.java
public abstract class Observer {
protected Subject subject;
public abstract void update();
}
步骤 3
创建实体观察者类。
BinaryObserver.java
public class BinaryObserver extends Observer{
public BinaryObserver(Subject subject){
this.subject = subject;
this.subject.attach(this);
}
@Override
public void update() {
System.out.println( "Binary String: "
+ Integer.toBinaryString( subject.getState() ) );
}
}
OctalObserver.java
public class OctalObserver extends Observer{
public OctalObserver(Subject subject){
this.subject = subject;
this.subject.attach(this);
}
@Override
public void update() {
System.out.println( "Octal String: "
+ Integer.toOctalString( subject.getState() ) );
}
}
HexaObserver.java
public class HexaObserver extends Observer{
public HexaObserver(Subject subject){
this.subject = subject;
this.subject.attach(this);
}
@Override
public void update() {
System.out.println( "Hex String: "
+ Integer.toHexString( subject.getState() ).toUpperCase() );
}
}
步骤 4
使用 Subject 和实体观察者对象。
ObserverPatternDemo.java
public class ObserverPatternDemo {
public static void main(String[] args) {
Subject subject = new Subject();
new HexaObserver(subject);
new OctalObserver(subject);
new BinaryObserver(subject);
System.out.println("First state change: 15");
subject.setState(15);
System.out.println("Second state change: 10");
subject.setState(10);
}
}
步骤 5
执行程序,输出结果:
First state change: 15 Hex String: F Octal String: 17 Binary String: 1111 Second state change: 10 Hex String: A Octal String: 12 Binary String: 1010
fatcheung
134***7025@qq.com
观察者模式,我理解的就是观察者订阅被观察者的状态,当被观察者状态改变的时候会通知所有订阅的观察者的过程。所以以下这种写法会不会更加容易理解一些呢?
观察者接口:
第一个观察者:
第二个观察者:
第三个观察者:
被观察者:
使用方法:
运行结果: test.F_Observer : msg changetest.S_Observer : msg changetest.T_Observer : msg changefatcheung
134***7025@qq.com
DHclly
335***817@qq.com
用 C# 实现了示例并优化了一下:
Subject.cs
Observer.cs
BinaryObserver.cs
OctalObserver.cs
HexaObserver.cs
Demo.cs
DHclly
335***817@qq.com
jade
guo***u_study@163.com
Observer 模式的定义:该模式定义了对象之间的一对多依赖关系,Subject 对象是一,Observer 对象是多。当 Subject 对象的状态发生改变时,所有依赖于该 Subject 对象的 Observer 对象都会得到通知,并且自动更新。
仔细分析定义,要精确理解观察者模式主要注意三点:
1.定义了对象间的一对多依赖关系;
2.当 Subject 对象的状态发生改变时,所有依赖于该 Subject 对象的 Observer 对象都会得到通知;
3.Observer 对象得到通知后,会自动更新,而不是被动;
其它的所有点都是细枝末节,由具体业务需求来决定。比如:
1. Subject 角色是应该定义成类?比如 内置的 java.util.Observable;还是应该定义成接口,以规避Java不支持多重继承的问题?比如《Head First 设计模式》中的推荐作法。
2.应该在什么时候订阅主题(或者说注册观察者)?是实例化观察者对象的同时?比如贴主的示例;还是由客户自主决定?比如此贴的第一篇分享笔记。
3.是否应该实现取消订阅功能(或者说取消注册)?
4.主题对象通知观察者时,是否携带消息?换句话说,是“推”消息?如贴主示例;还是“拉”消息?
5.是否支持多线程?
jade
guo***u_study@163.com
iwh冬
630***826@qq.com
参考地址
看了上面的代码,用 kotlin 实现了一下:
iwh冬
630***826@qq.com
参考地址
shenshaonian
134***3404@qq.com
观音洒水
shenshaonian
134***3404@qq.com
郭艺宾
guo***990@163.com
利用JDK实现观察者模式,在一对多中,一方代码:
多方代码:
运行测试类:
运行结果:
郭艺宾
guo***990@163.com
infiniteH
212***971@qq.com
被观察对象与观察者对象
一个被观察对象关联多个观察者对象
所以,被观察对象有个容器,去存储观察者对象
观察者对象也有一个被观察对象的成员变量
当被观察对象的某个属性发生改变,想让所以与之关联的观察者对象作出响应,就在改变属性的方法中,调用通知方法,所以需要声明一个通知方法,就是遍历所有观察者,调用一个观察者都有的方法,也就是update更新方法。
本质就是在更改某个属性后,遍历所有元素的某个方法,其实也就是多态
infiniteH
212***971@qq.com
Siskin.xu
sis***@sohu.com
Python 方式:
Siskin.xu
sis***@sohu.com
glory
809***053@qq.com
你的观察者和被观察者有组合关系不好,可以改成依赖关系:
输出结果:
glory
809***053@qq.com
失业
gjh***04@qq.com
这样写好像更容易理解。
失业
gjh***04@qq.com
RUNOOB
429***967@qq.com
观察者模式可以实现松耦合,使得主题和观察者之间的关系更加灵活。它可以方便地添加新的观察者,以及在运行时动态地增加、删除或修改观察者。同时,观察者模式符合开闭原则,使得主题和观察者可以独立变化,而不会相互影响。
下面是一个简单的观察者模式示例,假设有一个天气监测系统,主题是天气数据,观察者是不同的显示设备,它们实时显示天气数据的变化:
在上面的示例中,我们定义了主题接口 WeatherData 和观察者接口 WeatherObserver,具体主题类 WeatherStation 和具体观察者类 DisplayDevice。通过注册观察者、更新状态和通知观察者的过程,实现了主题和观察者之间的交互。
RUNOOB
429***967@qq.com