java模式之观察者模式

观察者模式是对象的行为模式，顾名思义，即存在观察者和被观察者。 观察者模式可以让多个观察者同时监听同一个被观察对象，当被观察对象发生变化时，并通知所有观察者，使各个观察者能作出相应的响应。适当地运用观察者模式，能提高自身代码的设计水平。
　　观察者模式理解和编码都比较简单，通常包括以下步骤：

　　1. 设计观察者接口类；
　　2. 观察者类实现该接口；
　　3. 设计被观察者抽象类，该类中提供一些方法，如：添加观察者对象，删除观察者对象，把事件通知给各个观察者对象；
　　4. 设计被观察者类，继承被观察者抽象类，在该类中，可以根据需要在该类中，可以定义方法：被观察者是否发生变化

　　以上四步，即完成了观察者模式的设计。下面代码分类进行描述以上步骤：

package Observer;

import java.util.Enumeration;
import java.util.Vector;

abstract public class Subject {

private Vector observersVector = new java.util.Vector();

public void attach(Observer observer){
  observersVector.addElement(observer);
  System.out.println("Attached an observer.");
}

public void detach(Observer observer){
  observersVector.removeElement(observer);
}

public void notifyObservers(){
  java.util.Enumeration enumeration = observers();
  while(enumeration.hasMoreElements()){
   System.out.println("Before notifying");
   ((Observer)enumeration.nextElement()).update();
  }
}

public Enumeration observers(){
  return ((java.util.Vector)observersVector.clone()).elements();
}
}


package Observer;

public class ConcreteSubject extends Subject{

private String state;

public void change(String newState){
  state = newState;
  this.notifyObservers();
}
}


package Observer;

public interface Observer {

void update();
}


package Observer;

public class ConcreteObserver implements Observer{

public void update(){
  System.out.println("I am notified.");
}

}


package Observer;

public class Client {

private static ConcreteSubject subject;
private static Observer observer1;
private static Observer observer2;

public static void main(String[] args){
  subject = new ConcreteSubject();
  observer1 = new ConcreteObserver();
  observer2 = new ConcreteObserver();
 
  subject.attach(observer1);
  subject.attach(observer2);
 
  subject.change("new state");
}
}


运行结果是：

Attached an observer.
Attached an observer.
Before notifying
I am notified.
Before notifying
I am notified.


在java中提供了Observerable类和Observer接口来实现观察者模式


public class Observable
extends Object
此类表示模型视图范例中的 observable 对象，或者说“数据”。可将其子类化，表示应用程序想要观察的对象（即被观察者）。

一个 observable 对象可以有一个或多个观察者。观察者可以是实现了 Observer 接口的任意对象。一个 observable 实例改变后，调用 Observable 的 notifyObservers 方法的应用程序会通过调用观察者的 update 方法来通知观察者该实例发生了改变。

未指定发送通知的顺序。Observable 类中所提供的默认实现将按照其注册的重要性顺序来通知 Observers，但是子类可能改变此顺序，从而使用非固定顺序在单独的线程上发送通知，或者也可能保证其子类遵从其所选择的顺序。

注意，此通知机制与线程无关，并且与 Object 类的 wait 和 notify 机制完全独立。

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


public interface Observer
一个可在观察者要得到 observable 对象更改通知时可实现 Observer 接口的类。
给个用java机制来实现观察者模式的例子
在java机制中Observable类相当于抽象主题角色，我们定义具体主题角色来继承该类
Observer 接口相当于抽象观察者角色，我们定义具体观察者角色来实现该接口
所以这两个抽象角色我们不用编写了 只需编写两个具体角色

//－－－－具体观察对象角色
package Observer.javaObserver;

import java.util.Observable;

public class Product extends Observable{

private String name;
private float price;

public String getName(){
  return name;
}

public void setName(String name){
  this.name = name;
  // 设置变化点
  setChanged();
  notifyObservers(name);//通知观察者
}

public float getPrice() {
  return price;
}

public void setPrice(float price) {
  this.price = price;
  //设置变化点
  setChanged();
  notifyObservers(new Float(price));
}

public void saveToDb(){
  System.out.println("saveToDb");
}
}

//------------ 两个具体观察者角色
package Observer.javaObserver;

import java.util.Observable;
import java.util.Observer;

public class NameObserver implements Observer {

private String name = null;

public void update(Observable obj, Object arg){
  if(arg instanceof String){
   name = (String)arg;
   System.out.println("NameObserver:name changed to " + name);
  }
}
}

package Observer.javaObserver;

import java.util.Observable;
import java.util.Observer;

public class PriceObserver implements Observer{

private float price=0;

public void update(Observable obj, Object arg){
  if(arg instanceof Float){
   price = ((Float)arg).floatValue();
   System.out.println("PriceObserver: price change to" + price);
  }
}
}

//－－－－测试程序

package Observer.javaObserver;

import java.util.Observer;

public class Test {

public static void main(String[] args){
  Product product = new Product();
  Observer nameObs = new NameObserver();
  Observer priceObs = new PriceObserver();
 
  product.addObserver(nameObs);
  product.addObserver(priceObs);
 
  product.setName("apple");
  product.setPrice(9.22f);
 
  product.setName("Apple");
  product.setPrice(9.88f);
  }
}


//－－－运行结果

NameObserver:name changed to apple
PriceObserver: price change to9.22
NameObserver:name changed to Apple
PriceObserver: price change to9.88