1、观察者模式介绍
观察者(Observer)模式的定义:指多个对象间存在一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式,它是对象行为型模式。
观察者模式是一种对象行为型模式,其主要优点如下。
- 降低了目标与观察者之间的耦合关系,两者之间是抽象耦合关系。符合依赖倒置原则。
- 目标与观察者之间建立了一套触发机制。
它的主要缺点如下。
- 目标与观察者之间的依赖关系并没有完全解除,而且有可能出现循环引用。
- 当观察者对象很多时,通知的发布会花费很多时间,影响程序的效率。
2、使用场景以及例子
1、简单的使用
public class ObserverPatternDemo01 {
@Test
public void demo1() {
Subject1 subject1 = new Subject1();
Observer1 observer1 = new Observer1();
Observer2 observer2 = new Observer2();
subject1.addObserver(observer1);
subject1.addObserver(observer2);
subject1.notifyAllObserver();
}
/**
* 创建观察者接口
*/
interface Observer {
//观察者做出响应
void response();
}
//观察者1
class Observer1 implements Observer {
@Override
public void response() {
System.out.println("观察者1做出反应");
}
}
//观察者2
class Observer2 implements Observer {
@Override
public void response() {
System.out.println("观察者2做出反应");
}
}
/**
* 创建目标,被观察者
*/
interface Subject {
//引入所有观察者
List<Observer> observers = new ArrayList<>();
//增加观察者
default void addObserver(Observer obser) {
observers.add(obser);
}
//移除观察者
default void removeObserver(Observer observer) {
observers.remove(observer);
}
//通知所有观察者,这个让具体的目标实现,不提供默认实现
void notifyAllObserver();
}
class Subject1 implements Subject {
@Override
public void notifyAllObserver() {
System.out.println("目标1来了");
for (Observer observer : observers) {
observer.response();
}
}
}
}
2、扩展使用–公司业务与汇率
/**
* 实例1.公司业绩和汇率
* 分析:当“人民币汇率”升值时,进口公司的进口产品成本降低且利润率提升,出口公司的出口产品收入降低且利润率降低;当“人民币汇率”贬值时,进口公司的进口产品成本提升且利润率降低,出口公司的出口产品收入提升且利润率提升。
* <p>
* 这里的汇率(Rate)类是目标类,它包含了保存观察者(Company)的 List 和增加/删除观察者的方法,以及有关汇率改变的抽象方法 change(int number);而人民币汇率(RMBrate)类是具体目标, 它实现了父类的 change(int number) 方法,
* 即当人民币汇率发生改变时通过相关公司;公司(Company)类是抽象观察者,它定义了一个有关汇率反应的抽象方法 response(int number);进口公司(ImportCompany)类和出口公司(ExportCompany)类是具体观察者类,它们实现了父类的 response(int number) 方法,
* 即当它们接收到汇率发生改变的通知时作为相应的反应
*/
public class ObserverPatternDemo02 {
@Test
public void demo1() {
Rate subject1 = new ChinaRate();
Company1 observer1 = new Company1();
Company2 observer2 = new Company2();
subject1.addObserver(observer1);
subject1.addObserver(observer2);
subject1.rateChange(2);
}
/**
* 创建观察者接口
*/
interface Company {
//观察者做出响应
void response(int number);
}
//观察者1
class Company1 implements Company {
@Override
public void response(int number) {
if (number > 0) {
System.out.println("人民币汇率升值" + number + "个基点,降低了进口产品成本,提升了进口公司利润率。");
} else if (number < 0) {
System.out.println("人民币汇率贬值" + (-number) + "个基点,提升了进口产品成本,降低了进口公司利润率。");
}
}
}
//观察者2
class Company2 implements Company {
@Override
public void response(int number) {
if (number > 0) {
System.out.println("人民币汇率升值" + number + "个基点,降低了出口产品收入,降低了出口公司的销售利润率。");
} else if (number < 0) {
System.out.println("人民币汇率贬值" + (-number) + "个基点,提升了出口产品收入,提升了出口公司的销售利润率。");
}
}
}
/**
* 创建目标,被观察者
*/
interface Rate {
//引入所有观察者
List<Company> companies = new ArrayList<>();
//增加观察者
default void addObserver(Company company) {
companies.add(company);
}
//移除观察者
default void removeObserver(Company company) {
companies.remove(company);
}
//通知所有观察者,这个让具体的目标实现,不提供默认实现
void rateChange(int rate);
}
class ChinaRate implements Rate {
@Override
public void rateChange(int rate) {
System.out.println("中国汇率变了");
for (Company company : companies) {
company.response(rate);
}
}
}
}
3、通过Java自带的类实现观察者
在 Java 中,通过 java.util.Observable 类和 java.util.Observer 接口定义了观察者模式,只要实现它们的子类就可以编写观察者模式实例。
- Observable类
Observable 类是抽象目标类,它有一个 Vector 向量,用于保存所有要通知的观察者对象,下面来介绍它最重要的 3 个方法。
void addObserver(Observer o) 方法:用于将新的观察者对象添加到向量中。
void notifyObservers(Object arg) 方法:调用向量中的所有观察者对象的 update() 方法,通知它们数据发生改变。通常越晚加入向量的观察者越先得到通知。
void setChange() 方法:用来设置一个 boolean 类型的内部标志位,注明目标对象发生了变化。当它为真时,notifyObservers() 才会通知观察者。 - Observer 接口
Observer 接口是抽象观察者,它监视目标对象的变化,当目标对象发生变化时,观察者得到通知,并调用 void update(Observable o,Object arg) 方法,进行相应的工作。
/**
* 【例3】利用 Observable 类和 Observer 接口实现原油期货的观察者模式实例。
* <p>
* 分析:当原油价格上涨时,空方伤心,多方局兴;当油价下跌时,空方局兴,多方伤心。本实例中的抽象目标(Observable)类在 Java 中已经定义,可以直接定义其子类,即原油期货(OilFutures)类,
* 它是具体目标类,该类中定义一个 SetPriCe(float price) 方法,当原油数据发生变化时调用其父类的 notifyObservers(Object arg) 方法来通知所有观察者;另外,
* 本实例中的抽象观察者接口(Observer)在 Java 中已经定义,只要定义其子类,即具体观察者类(包括多方类 Bull 和空方类 Bear),并实现 update(Observable o,Object arg) 方法即可。图 5 所示是其结构图。
*/
public class ObserverPatternDemo03 {
@Test
public void demo1() {
OilFutures oil = new OilFutures();
Observer bull = new Bull(); //多方
Observer bear = new Bear(); //空方
oil.addObserver(bull);
oil.addObserver(bear);
oil.setPrice(10);
oil.setPrice(-8);
}
//多方bull
class Bull implements Observer {
@Override
public void update(Observable o, Object arg) {
Float price = ((Float) arg).floatValue();
if (price > 0) {
System.out.println("油价上涨" + price + "元,多方高兴了!");
} else {
System.out.println("油价下跌" + (-price) + "元,多方伤心了!");
}
}
}
//具体观察者类:空方
class Bear implements Observer {
public void update(Observable o, Object arg) {
Float price = ((Float) arg).floatValue();
if (price > 0) {
System.out.println("油价上涨" + price + "元,空方伤心了!");
} else {
System.out.println("油价下跌" + (-price) + "元,空方高兴了!");
}
}
}
//目标-原油期货
class OilFutures extends Observable {
private float price;
public float getPrice() {
return price;
}
public void setPrice(float price) {
super.setChanged();
super.notifyObservers(price);
this.price = price;
}
}
}
3、总结
总体来说,观察者模式在实际的项目运用中还是非常广泛的,比如通讯、监听等。这个设计模式个人觉得比较能体现java的一个特征,就是多态,通过子类的父类或者实现类的接口,做一个统一的方法调用。这个设计模式和发布订阅模式还有点区别,下次也记录一下。