设计模式——观察者模式

观察者模式

观察者模式（Observer Pattern）也叫做发布订阅模式（Publish/subscribe）：定义对象间一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

角色名称：

• Subject被观察者：定义被观察者必须实现的职责，它必须能够动态地增加、取消观察者。一般是抽象类或实现类，仅仅完成作为被观察者必须实现的职责：管理观察者并通知观察者。
• Observer观察者：观察者接收到消息后，即进行update（更新方法）操作，对接收到的信息进行处理。
• ConcreteSubject具体的被观察者：定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。
• ConcreteObserver具体的观察者：每个观察者在接收到消息后的处理反应是不同，各个观察者有自己的处理逻辑。

被观察者Subject：

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(); 
        } 
    } 
}

具体被观察者ConcreteSubject：

public class ConcreteSubject extends Subject { 
    public void doSomething(){ 
        super.notifyObservers(); 
    } 
}

观察者Observer：

public interface Observer { 
    //更新方法 
    public void update(); 
}

具体观察者ConcreteObserver：

public class ConcreteObserver implements Observer { 
    //实现更新方法 
    public void update() { 
        System.out.println("接收到信息，并进行处理！"); 
    } 
}

场景类Client：

public class Client { 
    public static void main(String[] args) { 
        //创建一个被观察者 
        ConcreteSubject subject = new ConcreteSubject(); 
        //定义一个观察者 
        Observer obs= new ConcreteObserver(); 
        //观察者观察被观察者 
        subject.addObserver(obs); 
        //观察者开始活动了 
        subject.doSomething(); 
    } 
}

---

观察者模式的优点

• 观察者和被观察者之间是抽象耦合：如此设计，不管是增加观察者还是被观察者都非常容易扩展。
• 建立一套触发机制：根据单一职责原则，每个类的职责是单一的，形成了一个触发链。观察者模式可以完美地实现这里的链条形式。

观察者模式的缺点

观察者模式需要考虑一下开发效率和运行效率问题，一个被观察者，多个观察者，开发和调试就会比较复杂，而且在Java中消息的通知默认是顺序执行，一个观察者卡壳，会影响整体的执行效率。在这种情况下，一般考虑采用异步的方式。多级触发时的效率更是让人担忧，大家在设计时注意考虑。

观察者模式的使用场景

• 关联行为场景。需要注意的是，关联行为是可拆分的，而不是“组合”关系。
• 事件多级触发场景。
• 跨系统的消息交换场景，如消息队列的处理机制。

观察者模式的注意事项

可能存在广播链的问题：如果你做过数据库的触发器，你就应该知道有一个触发器链的问题，比如表A上写了一个触发器，内容是一个字段更新后更新表B的一条数据，而表B上也有个触发器，要更新表C，表C也有触发器……完蛋了，这个数据库基本上就毁掉了！我们的观察者模式也是一样的问题，一个观察者可以有双重身份，既是观察者，也是被观察者，当链一旦建立，这个逻辑就比较复杂，可维护性非常差，根据经验建议，在一个观察者模式中最多出现一个对象既是观察者也是被观察者，也就是说消息最多转发一次（传递两次），这还是比较好控制的。

注意：它和责任链模式的最大区别就是观察者广播链在传播的过程中消息是随时更改的，它是由相邻的两个节点协商的消息结构；而责任链模式在消息传递过程中基本上保持消息不可变，如果要改变，也只是在原有的消息上进行修正。

异步处理问题：被观察者发生动作了，观察者要做出回应，如果观察者比较多，而且处理时间比较长。可以使用异步，异步处理要考虑线程安全和队列的问题。

观察者模式的扩展

• Java世界中的观察者模式
• 项目中真实的观察者模式
• 订阅发布模型

最佳实践：

• 文件系统：在一个目录下新建立一个文件，“文件”是一个被观察者，“目录管理器”和“磁盘管理器”则是观察者。
• 猫鼠游戏：夜里猫叫一声，家里的老鼠撒腿就跑，同时也吵醒了熟睡的主人，这个场景中，“猫”就 是被观察者，老鼠和人是观察者。
• 广播收音机：电台就是被观察者，收音机就是观察者。

---

观察者模式的实例

战争时期，李斯想知道韩非子的一切，那么李斯就是观察者，韩非子就行被观察者。

这里我们仅实现了LiSi和LiuSi类，WangSi类没有去实现，从实现的两个类中可以发现，增加观察者模式非常简单，只需要新建一个类并实现Observer方法即可，在场景类中就可以直接使用。

（1）被观察者自身的活动IHanFeiZi：

public interface IHanFeiZi {
	public void haveBreakfast();
	public void haveFun();
}

（2）被观察者关联观察者及信息发布Observable：

public interface Observable {
	//增加一个观察者
	public void addObserver(Observer observer);
	//删除一个观察者
	public void deleteObserver(Observer observer);
	//将改变的动作发送给观察者
	public void notifyObserver(String context);
}

（3）观察者Observer，实现了信息的更新

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

（4）实际被观察者HanFeiZi ：

import java.util.ArrayList;
import com.sfq.impl.IHanFeiZi;
import com.sfq.impl.Observable;
import com.sfq.impl.Observer;
public class HanFeiZi implements IHanFeiZi, Observable {
	//定义一个变长数组，存放所有观察者
	private ArrayList<Observer> observerList = new ArrayList<Observer>();
	@Override
	public void addObserver(Observer observer) {
		this.observerList.add(observer);
	}
	@Override
	public void deleteObserver(Observer observer) {
		this.observerList.remove(observer);
	}
	@Override
	public void notifyObserver(String context) {
		for(Observer observer:observerList) {
			observer.update(context);
		}
	}
	@Override
	public void haveBreakfast() {
		System.out.println("韩非子：开始吃饭了...");
		this.notifyObserver("韩非子在吃饭");
	}
	@Override
	public void haveFun() {
		System.out.println("韩非子：开始娱乐了...");
		this.notifyObserver("韩非子在娱乐");
	}
}

（5）实际观察者LiSi和LiuSi：

import com.sfq.impl.Observer;
public class LiSi implements Observer {
	@Override
	public void update(String context) {
		System.out.println("李斯：观察韩非子活动，并报告");
		this.reportToQinShiHuang(context);
		System.out.println("李斯：汇报完毕\n");
	}
	private void reportToQinShiHuang(String reportContext) {
		System.out.println("李斯：报告-->" + reportContext);
	}
}

import com.sfq.impl.Observer;
public class LiuSi implements Observer {
	@Override
	public void update(String context) {
		System.out.println("刘斯：观察韩非子活动，并报告");
		this.happy(context);
		System.out.println("刘斯：汇报完毕\n");
	}
	private void happy(String reportContext) {
		System.out.println("刘斯：乐的屁颠屁颠的报告-->" + reportContext);
	}
}

（6）场景类Client：

import com.sfq.action.HanFeiZi;
import com.sfq.action.LiSi;
import com.sfq.action.LiuSi;
import com.sfq.impl.Observer;
public class Client {
	public static void main(String[] args) {
		//实例观察者
		Observer liSi = new LiSi();
		Observer liuSi = new LiuSi();
		//被观察者
		HanFeiZi hanFeiZi = new HanFeiZi();
		hanFeiZi.addObserver(liSi);
		hanFeiZi.addObserver(liuSi);
		hanFeiZi.haveBreakfast();
	}
}

结果
韩非子：开始吃饭了...
李斯：观察韩非子活动，并报告
李斯：报告-->韩非子在吃饭
李斯：汇报完毕

刘斯：观察韩非子活动，并报告
刘斯：乐的屁颠屁颠的报告-->韩非子在吃饭
刘斯：汇报完毕

（7）Java世界中的观察者模式

JDK中提供了：java.util.Observable实现类和java.util.Observer接口，也就是说我们上面写的那个例子中的Observable接口可以改换成java.util.Observale实现类。

import java.util.Observable;
import com.sfq.impl.IHanFeiZi;
public class HanFeiZiJava extends Observable implements IHanFeiZi {
	@Override
	public void haveBreakfast() {
		System.out.println("韩非子：开始吃饭了...");
		super.setChanged();
		super.notifyObservers("韩非子在吃饭");
	}
	@Override
	public void haveFun() {
		System.out.println("韩非子：开始娱乐了...");
		super.setChanged();
		super.notifyObservers("韩非子在娱乐");
	}
}

import java.util.Observable;
import java.util.Observer;
public class LiSiJava implements Observer {
	@Override
	public void update(Observable observable, Object object) {
		System.out.println("李斯：观察韩非子活动，并报告");
		this.reportToQinShiHuang(object.toString());
		System.out.println("李斯：汇报完毕\n");
	}
	private void reportToQinShiHuang(String reportContext) {
		System.out.println("李斯：报告-->" + reportContext);
	}
}

import java.util.Observer;
import com.sfq.action.HanFeiZiJava;
import com.sfq.action.LiSiJava;
public class Client {
	public static void main(String[] args) {
		Observer liSi = new LiSiJava();
		HanFeiZiJava hanFeiZi = new HanFeiZiJava();
		hanFeiZi.addObserver(liSi);
		hanFeiZi.haveBreakfast();
	}
}

结果
韩非子：开始吃饭了...
李斯：观察韩非子活动，并报告
李斯：报告-->韩非子在吃饭
李斯：汇报完毕

（8）项目中的观察者模式

在系统设计中会对观 察者模式进行改造或改装，主要在以下3个方面：

★ 观察者和被观察者之间的消息沟通

实际中一般的做法是：

• 观察者中的update方法接受两个参数，一个是被观察者，一个是DTO（Data Transfer Object，数据传输对象），DTO一般是一个纯洁的JavaBean，由被观察者生成，由观察者消费。
• 当然，如果考虑到远程传输，一般消息是以XML格式传递。

★ 观察者响应方式

观察者快速响应，有两个办法：

• 采用多线程技术，甭管是被观察者启动线程还是观察者启动线程，都可以明显地提高系统性能，这就是通常所说的异步架构；
• 缓存技术：不管谁来，都准备足够的资源给它，以保证快速响应。代价是开发难度大，且压力测试要做充分，这就是同步架构。

★ 被观察者尽量自己做主

对被观察者的业务逻辑doSomething方法实现重载，如增加一个doSomething(boolean isNotifyObs)方法，决定是否通知观察者，而不是在消息到达观察者时才判断是否要消费。

（9）订阅发布模型

在EJB中有3个类型的Bean: Session Bean、Entity Bean和MessageDriven Bean。MessageDriven Bean（一般简称为MDB），消息驱动Bean，消息的发布者（Provider）发布一个消息，也就是一个消息驱动Bean，通过EJB容器（一般是Message Queue消息队列）通知订 阅者做出回应，从原理上看很简单，就是观察者模式的升级版，或者说是观察则模式的BOSS版。