您的位置: 首页  >  文章  >  观察者模式-设计模式-笔记（一）

观察者模式-设计模式-笔记（一）

分类: 文章 • 2023-02-07 00:12:13

出版者+订阅者==观察者模式

 

报纸的订阅

 

出版者改称为”主题“（Subject），订阅者改称为”观察者“（Observer）

 

 

观察者模式定义了一系列对象之间的一对多关系。

 

当一个对象改变状态，其他依赖者都会收到通知。

 

主题：

这样或许不行，只是我必须因此门户大开，让你们全都可以进来取得你们需要的状态，这样太危险了。我不能让你们进来里面大肆挖掘我的各种数据

 

观察者：

为何由你主动送数据过来，而不是让我们主动去向你索取数据？

你 何不提供一些公开的getter方法，让我们”拉“走我们需要的状态？

 

 

 

 

观察者模式定义了对象间的一对多依赖关系，让一个或多个观察者对象观察一个主题对象。当主题对象的状态发生变化时，系统能通知所有的依赖于此对象的观察者对象，从而使得观察者对象能够自动更新。

在观察者模式中，被观察的对象常常也被称为目标或主题（Subject），依赖的对象被称为观察者（Observer）。

下面以一个简单的示例来示范观察者模式，程序先提供一个观察者接口：

程序清单：codes\09\9.3\Observer\Observer.java

public interface Observer
{
void update(Observable o , Object arg);
}

上面Observer接口是一个观察者接口，程序中所有观察者都应该实现该接口。在该接口的update()方法中包含了一个Observable类型的参数，该参数代表被观察对象，也就是前面介绍的目标或主题。此处的Observable是一个抽象基类，程序中被观察者应该继承该抽象基类。

Observable类的代码如下：

程序清单：codes\09\9.3\Observer\Observable.java

public abstract class Observable
{
//用一个List来保存该对象上所有绑定的事件监听器
List<Observer> observers = 
new ArrayList<Observer>();
//定义一个方法，用于从该主题上注册观察者
public void registObserver(Observer o)
{
observers.add(o);
}
//定义一个方法，用于从该主题中删除观察者
public void removeObserver(Observer o)
{
observers.add(o);
}
//通知该主题上注册的所有观察者
public void notifyObservers(Object value)
{
//遍历注册到该被观察者上的所有观察者
for (Iterator it = observers.iterator(); 
it.hasNext(); )
{
Observer o = (Observer)it.next();
//显示每个观察者的update方法
o.update(this , value);
}
}
}

该Observable抽象类是所有被观察者的基类，它主要提供了registObserver()方法用于注册一个新的观察者；并提供了一个removeObserver()方法用于删除一个已注册的观察者；当具体被观察对象的状态发生改变时，具体被观察对象会调用notifyObservers方法来通知所有观察者。

下面提供一个具体的被观察者类：Product，该产品有两个属性，它继承了Observable抽象基类。程序如下：

程序清单：codes\09\9.3\Observer\Product.java

public class Product extends Observable
{
//定义两个属性
private String name;
private double price;
//无参数的构造器
public Product(){}
public Product(String name , double price)
{
this.name = name;
this.price = price;
}
public String getName()
{
return name;
}
//当程序调用name的setter方法来修改Product的name属性时
//程序自然触发该对象上注册的所有观察者
public void setName(String name)
{
this.name = name;
notifyObservers(name);
}
public double getPrice()
{
return price;
}
//当程序调用price的setter方法来修改Product的price属性时
//程序自然触发该对象上注册的所有观察者
public void setPrice(double price)
{
this.price = price;
notifyObservers(price);
}
}

正如程序中两行粗体字代码所示，当程序调用Product对象的setName()、setPrice()方法来改变Product的name、price属性时，这两个方法将自动触发Observable基类的notifyObservers方法。

 

接下来程序提供两个观察者，一个用于观察Product对象的name属性，另一个用于观察Product对象的price属性。

程序清单：codes\09\9.3\Observer\NameObserver.java

public class NameObserver implements Observer
{
//实现观察者必须实现的update方法
public void update(Observable o , Object arg)
{
if (arg instanceof String )
{
//产品名称改变值在name中
String name = (String)arg;
//启动一个JFrame窗口来显示被观察对象的状态改变
JFrame f = new JFrame("观察者");
JLabel l = new JLabel("名称改变为：" + name);
f.add(l);
f.pack();
f.setVisible(true);
System.out.println("名称观察者:" +
o + "物品名称已经改变为: " + name);
}
}
}

程序清单：codes\09\9.3\Observer\PriceObserver.java

public class PriceObserver implements Observer
{
//实现观察者必须实现的update方法
public void update(Observable o , Object arg)
{ 
if(arg instanceof Double)
{
System.out.println("价格观察者:" +
o + "物品价格已经改变为: " + arg);
}
}
}

接着主程序创建一个Product对象（被观察的目标对象），然后向该被观察对象上注册两个观察者对象，当主程序调用Product对象的setter方法来改变该对象的状态时，注册在Product对象上的两个观察者将被触发。主程序代码如下：

程序清单：codes\09\9.3\Observer\Test.java

public class Test
{
public static void main(String[] args) 
{
//创建一个被观察者对象
Product p = new Product("电视机" , 176);
//创建两个观察者对象
NameObserver no = new NameObserver();
PriceObserver po = new PriceObserver();
//向被观察对象上注册两个观察者对象
p.registObserver(no);
p.registObserver(po);
//程序调用setter方法来改变Product的name和price属性
p.setName("书桌");
p.setPrice(345f);
}
}

运行上面程序，我们将可看到当Product的属性值发生改变时，注册在该Product上的NameObserver和PriceObserver将被触发。

纵观上面介绍的观察者模式，我们发现观察者模式通常包含如下4个角色：

被观察者的抽象基类：它通常会持有多个观察者对象的引用。Java提供了java.util.Observable基类来代表被观察者的抽象基类，所以实际开发中无须自己开发这个角色。

观察者接口：该接口是所有被观察对象应该实现的接口，通常它只包含一个抽象方法update()。Java同样提供了java.util.Observer接口来代表观察者接口，实际开发中也无须开发该角色。

被观察者实现类：该类继承Observable基类。

观察者实现类：实现Observer接口，实现update抽象方法。

理解了上面观察者模式的实现思路之后，可能有读者会感到疑惑：观察者模式的实现方式与Java事件机制的底层实现何其相似啊？实际上，我们完全可以把观察者接口理解成事件监听接口，而被观察者对象也可当成事件源来处理——换个角度来思考：监听，观察，这两个词语之间有本质的区别吗？Java事件机制的底层实现，本身就是通过观察者模式来实现的。

除此之外，观察者模式在Java EE应用中也有广泛应用，主题/订阅模式下的JMS（Java Message Service，Java消息服务）本身就是观察者模式的应用。图9.12显示了主题/订阅模式下JMS的示意图。

观察者模式-设计模式-笔记（一） 
图9.12  主题/订阅模式下JMS的示意图

从图9.12中可以看出，当Topic主题收到发布者（Publisher）发布的消息时，注册到该主题的所有订阅者（Subscriber）都可收到该消息。实际上，Java EE把这个Topic设计成一个被观察者，而所有订阅者都注册到该被观察者，当发布者发布消息时，该消息将会引起Topic主题的改变，这种改变将会触发注册到该Topic上的所有观察者。

 

 

相关推荐