设计模式_观察者模式

Observer Pattern
Define a ont-to-many dependency between objects so that when
one object changes state,all its dependents are notified and updated automatically.(定义对象间一种一对多的依赖关系，使得每当一个对象改变状态时，则所有依赖于它的对象都会得到通知并被自动更新)



● Subject被观察者
定义被观察者必须实现的职责，它必须能够动态地增加、取消观察者。它一般是抽象类 或者是实现类，仅仅完成作为被观察者必须实现的职责：管理观察者并通知观察者。

● Observer观察者
观察者接收到消息后，即进行update（更新方法）操作，对接收到的信息进行处理

public abstract class Subject {
//定义一个观察者数组
private Vector<Observer> obsVector = new Vector<Observer>();
//增加一个观察者
public void addObserver(Observer o){
this.obsVector.add(o);
}
//删除一个观察者
public void delObserver(Observer o){
this.obsVector.remove(o);
}
//通知所有观察者
public void notifyObservers(){
for(Observer o:this.obsVector){
o.update();
}
}
}

例子
监控秦始皇，儒家，墨家，法家都严密监视秦始皇的行动。

public interface Observer {
 public void update(String context);
}

/**
 * 这个接口的存在就是对观察者的统一管理
 * @author suibian
 *
 */
public interface ObserverManage {
 
 public void addObserver(Observer observer);
 public void deleteObserver(Observer observer);
 public void notifyObservers(String context);
}

/** 
 * 被观察者，该有的都有 
 * @author suibian 
 * 
 */ 
public interface IEmperorQin { 
 public void haveLove(); 
 public void haveUnited(); 
}

public class EmperorQin implements ObserverManage,IEmperorQin{
 private ArrayList<Observer> observerList=new ArrayList<Observer>();
 
 /*private Vector<Observer> observerList=new ArrayList<Observer>(); 这样线程安全  */
 
 public void addObserver(Observer observer) {
  this.observerList.add(observer);
 }
 public void deleteObserver(Observer observer) {
  this.observerList.remove(observer);
 }
 public void notifyObservers(String context) {
  for(Observer ob:observerList){
   ob.update(context);
  }
 }
 public void haveLove() {
  System.out.println("秦始皇开始修阿房宫了");
  this.notifyObservers("秦始皇开始修阿房宫了");
 }
 public void haveUnited() {
  System.out.println("秦始皇已经统一天下了");
  this.notifyObservers("秦始皇已经统一天下了");
 }
}

public class RuJia implements Observer {
 public void update(String context) {
  System.out.println("儒家:看到李斯活动，准备配合");
  this.cry(context);
  System.out.println("儒家配合的好");
 }
 private void cry(String context) {
  System.out.println("儒家根据-》"+context+"制定了计划");
 }
}

public class MoJia implements Observer {
 public void update(String context) {
  System.out.println("墨家:观察到秦始皇活动，自己也开始行动了");
  this.cry(context);
  System.out.println("墨家修好了机关兽");
 }
 private void cry(String context) {
  System.out.println("墨家说，因为-》"+context+"所以我必须马上行动");
 }
}

public class FaJia implements Observer {
 public void update(String context) {
  System.out.println("法家:观察到秦始皇活动");
  this.reportToQinShiHuang(context);
  System.out.println("法家汇报完毕");
 }
 private void reportToQinShiHuang(String context) {
  System.out.println("法家:秦始皇有活动-》"+context);
 }
}

public class QinDynasty {
 
 public static void main(String[] args) {
  FaJia liSi=new FaJia();
  MoJia wanSi=new MoJia();
  RuJia rujia=new RuJia();
 
  EmperorQin qinshihuang=new EmperorQin();
 
  qinshihuang.addObserver(liSi);
  qinshihuang.addObserver(wanSi);
  qinshihuang.addObserver(rujia);
 
  qinshihuang.haveLove();
  qinshihuang.haveUnited();
 }
}
/*
如果这样设计，的确，订阅模式，但是前提是观察者需要被添加到被观察者的队列中
当被观察者行动时，循环队列，一个一个的调用队列中的提醒方法，也就是说，被观察者必须要知道观察者中的内部结构，
或者说他们俩个达成了某种协议
扩展性不好
代码结构清晰
*/

优点
观察者和被观察者是抽象耦合
触发机制形成了一个触发链

缺点
如果一个观察者卡壳...

使用场景
关联行为
多级触发
跨系统的消息交换

在java中已经有了一个java.util.Observer接口和 java.util.Observable接口，使用这俩个就显得非常简单了。

我是菜鸟，我在路上。