设计模式_观察者模式
Observer Pattern
D
efine 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接口，使用这俩个就显得非常简单了。
我是菜鸟，我在路上。