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