观察者模式java设计模式介绍



观察者模式java设计模式介绍。什么是java观察者模式？Observer观察者模式的含义是在多个对象之间定义一对多的关系，便于在一个对象状态发生改变时，别的依赖于这个对象的对象都可以得到通知，而且可以自动更新。在观察者设计模式里面，多个观察者以及被观察者之间的关系可以表示如下图：

observer观察者设计模式java设计模式

observer观察者设计模式java设计模式

java观察者模式频繁用于GUI应用程序中，java的观察者模式现在已经是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类

 

[java] view plaincopy
  1. package codolio.test;
  2. import java.util.Observable;
  3. public class Market extends Observable {
  5.     private float price;
  7.     public Market(float price) {
  8.         this.price = price;
  9.     }
  11.     public float getPrice() {
  12.         return this.price;
  13.     }
  15.     public void setPrice(float price) {
  16.         this.price = price;
  17.         setChanged();
  18.         notifyObservers();
  19.     }
  20. }

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

 

[java] view plaincopy
  1. package codolio.test;
  2. import java.util.Observable;
  3. import java.util.Observer;
  4. public class Company implements Observer {
  5.     @Override
  6.     public void update(Observable target, Object arg) {
  7.         Market market;
  9.         if (target instanceof Market) {
  10.             market = (Market)target;
  11.             System.out.println(“The stock price of my company is ” + market.getPrice());
  12.         }
  13.     }
  14. }

 

 

[java] view plaincopy
  1. package codolio.test;
  2. import java.util.Observable;
  3. import java.util.Observer;
  4. public class People implements Observer {
  5.     @Override
  6.     public void update(Observable target, Object arg) {
  7.         Market market;
  9.         if (target instanceof Market) {
  10.             market = (Market)target;
  11.             System.out.println(“The stock price of this company is ” + market.getPrice() + ” oh,yeah!!”);
  12.         }
  13.     }
  14. }

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

 

[java] view plaincopy
  1. package codolio.test;
  2. public class ObserverPattern {
  3.     /**
  4.      * @param args
  5.      */
  6.     public static void main(String[] args) {
  7.         Market market = new Market(10.5f);
  9.         Company company = new Company();
  10.         People people = new People();
  12.         market.addObserver(company);
  13.         market.addObserver(people);
  15.         market.setPrice(20.0f);
  16.     }
  17. }
  18. //输出结果
  19. The stock price of this company is 20.0 oh,yeah!!
  20. The stock price of my company is 20.0

 

  • 使用PropertyChangeSupport/PropertyChangeListener

 

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

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

（1）实现被观察者类

 

[java] view plaincopy
  1. package codolio.test;
  2. import java.beans.PropertyChangeListener;
  3. import java.beans.PropertyChangeSupport;
  4. public class Market {
  6.     private float price;
  8.     private PropertyChangeSupport changeSupport;
  10.     private Object objectLock = new Object();
  12.     public Market(float price) {
  13.         this.price = price;
  14.     }
  16.     public void addPropertyChangeListener(PropertyChangeListener listener) {
  18.         synchronized(getObjectLock()) {
  19.             if (listener == null) {
  20.                 return;
  21.             }
  23.             if (changeSupport == null) {
  24.                 changeSupport = new PropertyChangeSupport(this);
  25.             }
  27.             changeSupport.addPropertyChangeListener(listener);
  28.         }
  29.     }
  31.     public void removePropertyChangeListener(PropertyChangeListener listener) {
  32.         synchronized(getObjectLock()) {
  33.             if (listener == null || changeSupport == null) {
  34.                 return;
  35.             }
  37.             changeSupport.removePropertyChangeListener(listener);
  39.         }
  40.     }
  42.     protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
  43.         PropertyChangeSupport changeSupport;
  44.         synchronized (getObjectLock()) {
  45.             changeSupport = this.changeSupport;
  46.         }
  48.         if (changeSupport == null || (oldValue != null && newValue != null && oldValue.equals(newValue))) {
  49.             return;
  50.         }
  52.         changeSupport.firePropertyChange(propertyName, oldValue, newValue);
  53.     }
  55.     public void setPrice(float price) {
  56.         this.firePropertyChange(“price”, this.price, price);
  57.         this.price = price;
  58.     }
  60.     public float getPrice() {
  61.         return this.price;
  62.     }
  64.     Object getObjectLock() {
  65.         return objectLock;
  66.     }
  67. }


（2）实现观察者类

 

[java] view plaincopy
  1. package codolio.test;
  2. import java.beans.PropertyChangeEvent;
  3. import java.beans.PropertyChangeListener;
  4. public class Company implements PropertyChangeListener {
  5.     @Override
  6.     public void propertyChange(PropertyChangeEvent event) {
  7.         float price = ((Float)event.getNewValue()).floatValue();
  8.         System.out.println(“The stock price of my company is ” + price);
  9.     }
  10. }
[java] view plaincopy

  1. package codolio.test;
  2. import java.beans.PropertyChangeEvent;
  3. import java.beans.PropertyChangeListener;
  4. public class People implements PropertyChangeListener {
  5.     @Override
  6.     public void propertyChange(PropertyChangeEvent event) {
  7.         float price = ((Float)event.getNewValue()).floatValue();
  9.         System.out.println(“The stock price of this company is ” + price + ” oh,yeah!!”);
  10.     }
  11. }

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

 

[java] view plaincopy
  1. package codolio.test;
  2. public class ObserverPattern {
  3.     /**
  4.      * @param args
  5.      */
  6.     public static void main(String[] args) {
  7.         Market market = new Market(10.5f);
  9.         Company company = new Company();
  10.         People people = new People();
  12.         market.addPropertyChangeListener(company);
  13.         market.addPropertyChangeListener(people);
  15.         market.setPrice(20.0f);
  16.     }
  17. }
  18. //输出结果
  19. The stock price of my company is 20.0
  20. The stock price of this company is 20.0 oh,yeah!!

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