Observer（观察者）模式

Observer（观察者）模式的宗旨是在多个对象之间定义一对多的关系，以便当一个对象状态发生改变时，其它所有依赖于这个对象的对象都能够得到通知，并自动更新。在观察者设计模式中，多个观察者和被观察者之间的关系可以表示如下：

 

观察者模式频繁用于GUI应用程序中，它已经成为Java GUI类库的基本模式。随着应用程序和系统规模的不断扩大，我们必须对责任进行分解和重分解，从而使每个类和包都能保持在较小的规模，以便于系统维护。在多层设计中，MVC是一种常用的设计方法，MVC，即 模型/视图/控制器 ，指得是将对象（即模型）与显示它的GUI元素（即视图和控制器）相分离。 MVC设计可以把应用程序划分成松散耦合的层，每个层可以对立发生变化，每个层可以独立发生变化，并且可以运行在不同的机器上。

Java通过观察者模式来支持这种责任分离，其中实现设计的两个关键步骤如下：

1. 实现Observer接口的观察者类必须向自己所关注的对象（即被观察者）注册自己，收到通知后，观察者类必须做出合适的选择；
2. 扩展Observable类的被观察者类在它们的数据发生变化的时候，必须记得去通知相关的观察者。

 

在Java中，观察者模式的具体实现一般有以下两种方法：

• 使用Observable/Observer

（1）java.util.Observable

 

该类代表一个可观察的（即被观察者）对象。它可以被子类化，以便表示应用中想要观察的对象。一个可观察者对象可以拥有一个或者多个观察者。一个观察者可以是实现了Observer接口的任意对象。一个被观察者的实例发生变化后，调用被观察者对象的notifyObservers()方法的应用程序引发它所有的观察者被通知这次变化，并且调用它们的update方法。

 

当一个新的被观察者的对象被创建时，它的观察者集合是空的。并且当且仅当两个观察者的equals方法返回true时，两个观察者才被认为相等。

 

Observable类中常用的方法列表如下：

• public void addObserver(Observer o)：向被观察者对象添加一个观察者，假设被添加的观察者并不存在于集合中；
• public void deleteObserver(Observer o)：从被观察者对象的观察者集合中删除一个指定的观察者；
• protected void setChanged()：标记该被观察者对象已经被更改。

（2）java.util.Observer

 

public interface Observer：当一个类希望在一个被观察者对象发生变化时被通知应实现该Observer接口。该接口中定义的方法列表如下：

• void update(Observale o, Object arg)：当一个被观察者的象发生变化时该方法被调用。应用程序调用Observable对象的notifyObservers方法来通知所有观察者对象。其中：o代表被观察者对象，arg代表传递给notifyObservers方法的参数。

采用该方法的示例代码如下：

 

（1）实现Observable类

package codolio.test; import java.util.Observable; public class Market extends Observable { private float price; public Market(float price) { this.price = price; } public float getPrice() { return this.price; } public void setPrice(float price) { this.price = price; setChanged(); notifyObservers(); } }

（2）实现两个观察者类Company和People

package codolio.test; import java.util.Observable; import java.util.Observer; public class Company implements Observer { @Override public void update(Observable target, Object arg) { Market market; if (target instanceof Market) { market = (Market)target; System.out.println("The stock price of my company is " + market.getPrice()); } } }

 

package codolio.test; import java.util.Observable; import java.util.Observer; public class People implements Observer { @Override public void update(Observable target, Object arg) { Market market; if (target instanceof Market) { market = (Market)target; System.out.println("The stock price of this company is " + market.getPrice() + " oh,yeah!!"); } } }

（3）测试过程与输出结果

package codolio.test; public class ObserverPattern { /** * @param args */ public static void main(String[] args) { Market market = new Market(10.5f); Company company = new Company(); People people = new People(); market.addObserver(company); market.addObserver(people); market.setPrice(20.0f); } } //输出结果 The stock price of this company is 20.0 oh,yeah!! The stock price of my company is 20.0

• 使用PropertyChangeSupport/PropertyChangeListener

在使用第一种方式来实现观察者模式时，被观察者对象需要扩展Observable类，因为Java采用单继承模式，在很多时候，我们无法再继承Observable类。在第二种方式中，被观察者类持有一个PropertyChangeSupport类型的字段，使用组合而非继承来实现观察者模型。

 

采用该方法的示例代码可以表示如下：

 

（1）实现被观察者类

package codolio.test; import java.beans.PropertyChangeListener; import java.beans.PropertyChangeSupport; public class Market { private float price; private PropertyChangeSupport changeSupport; private Object objectLock = new Object(); public Market(float price) { this.price = price; } public void addPropertyChangeListener(PropertyChangeListener listener) { synchronized(getObjectLock()) { if (listener == null) { return; } if (changeSupport == null) { changeSupport = new PropertyChangeSupport(this); } changeSupport.addPropertyChangeListener(listener); } } public void removePropertyChangeListener(PropertyChangeListener listener) { synchronized(getObjectLock()) { if (listener == null || changeSupport == null) { return; } changeSupport.removePropertyChangeListener(listener); } } protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) { PropertyChangeSupport changeSupport; synchronized (getObjectLock()) { changeSupport = this.changeSupport; } if (changeSupport == null || (oldValue != null && newValue != null && oldValue.equals(newValue))) { return; } changeSupport.firePropertyChange(propertyName, oldValue, newValue); } public void setPrice(float price) { this.firePropertyChange("price", this.price, price); this.price = price; } public float getPrice() { return this.price; } Object getObjectLock() { return objectLock; } }

（2）实现观察者类

package codolio.test; import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; public class Company implements PropertyChangeListener { @Override public void propertyChange(PropertyChangeEvent event) { float price = ((Float)event.getNewValue()).floatValue(); System.out.println("The stock price of my company is " + price); } }

 

package codolio.test; import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; public class People implements PropertyChangeListener { @Override public void propertyChange(PropertyChangeEvent event) { float price = ((Float)event.getNewValue()).floatValue(); System.out.println("The stock price of this company is " + price + " oh,yeah!!"); } }

（3）测试过程与输出结果

package codolio.test; public class ObserverPattern { /** * @param args */ public static void main(String[] args) { Market market = new Market(10.5f); Company company = new Company(); People people = new People(); market.addPropertyChangeListener(company); market.addPropertyChangeListener(people); market.setPrice(20.0f); } } //输出结果 The stock price of my company is 20.0 The stock price of this company is 20.0 oh,yeah!!

 

无论是采用Observer、PropertyChangeSupport还是另外的类来建立Observer模式，关键是在对象间建立一对多的依赖关系。当一个对象的状态发生改变，所有依赖它的对象都会被通知并自动更新；Observer模式有助于缩小责任范围，减少观察对象和被观察对象的维护成本。