* 24种设计模式——观察者模式

核心：定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；

而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。 —— 工作中一般使用拉模式，因为可以拉取整个主题对象

一、只有李斯（观察者）监视韩非子（被观察者）

1. 被观察者接口

public interface IHanFeiZi {
	//韩非子也是人，也要吃饭
	public void haveBreakfast();
	//韩非子也有娱乐活动
	public void haveFun();
}

2. 具体的被观察者（通过聚集方式的被观察者）

public class HanFeiZi implements IHanFeiZi{
	//把李斯声明出来
	private ILiSi liSi = new LiSi();
	//韩非子要吃饭了
	public void haveBreakfast() {
		System.out.println("韩非子开始吃饭...");
		//通知李斯
		this.liSi.update("韩非子在吃饭...");
	}
	//韩非子要娱乐了
	public void haveFun() {
		System.out.println("韩非子开始娱乐...");
		this.liSi.update("韩非子在娱乐...");
	}
}

3. 抽象观察者

public interface ILiSi {
	//一发现别人有动静，自己也要行动起来
	public void update(String context);
}

4. 具体观察者

public class LiSi implements ILiSi{
	//首先李斯是个观察者，一旦韩非子有活动，他就知道，他就要向老板汇报
	public void update(String context) {
		System.out.println("李斯，观察到韩非子活动，开始向老板汇报了");
		this.reportToQinShiHuang(context);
		System.out.println("李斯，汇报完了..");
	}
	//李斯报告秦始皇
	public void reportToQinShiHuang(String reportContext){
		System.out.println("李斯，报告，韩非子有活动了-->"+reportContext);
	}
}

5. 通过聚集方式的场景类

public class Client {
	public static void main(String[] args) throws InterruptedException {
		//定义出韩非子
		IHanFeiZi hanFeiZi = new HanFeiZi();
		//然后我们看看韩非子在干什么
		hanFeiZi.haveBreakfast();
		//韩非子娱乐了
		hanFeiZi.haveFun();
	}
}

二、多个观察者（观察者）监视韩非子（被观察者）

1. 韩非子（被观察者）特有的方法

/**
 * 韩非子特有的方法
 */
public interface IHanFeiZi {
	//韩非子也是人，也要吃饭
	public void haveBreakfast();
	//韩非子也有娱乐活动
	public void haveFun();
}

2. 被观察者接口

/**
 * 实现该接口的都是被观察者
 */
public interface Observable {
	//增加一个观察者
	public void addObserver(Observer observer);
	//删除一个观察者
	public void deleteObserver(Observer observer);
	//既然要观察，我发生改变了他也应该有所动作，通知观察者
	public void notifyObservers(String context);
}

3.  观察者接口

/**
 * 实现该接口的都是观察者
 */
public interface Observer {
	//一发现别人有动静，自己也要行动起来
	public void update(String context);
}

4. 具体被观察者实现类

public class HanFeiZi implements IHanFeiZi,Observable{
	//定义个变长的数组，存放所有的观察者
	private List<Observer> observerList = new ArrayList<Observer>();
	//增加观察者
	public void addObserver(Observer observer) {
		observerList.add(observer);
	}
	//删除观察者
	public void deleteObserver(Observer observer) {
		observerList.remove(observer);
	}
	//通知所有观察者
	public void notifyObservers(String context) {
		for(Observer obs : observerList){
			obs.update(context);
		}
	}
	//韩非子要吃饭了
	public void haveBreakfast() {
		System.out.println("韩非子开始吃饭...");
		//通知所有观察者
		this.notifyObservers("韩非子在吃饭...");
	}
	//韩非子要娱乐了
	public void haveFun() {
		System.out.println("韩非子开始娱乐...");
		//通知所有观察者
		this.notifyObservers("韩非子在娱乐...");
	}
}

5. 具体观察者实现类

public class LiSi implements Observer{
	//首先李斯是个观察者，一旦韩非子有活动，他就知道，他就要向老板汇报
	public void update(String context) {
		System.out.println("李斯，观察到韩非子活动，开始向老板汇报了");
		this.reportToQinShiHuang(context);
		System.out.println("李斯，汇报完了..");
	}
	//李斯报告秦始皇
	public void reportToQinShiHuang(String reportContext){
		System.out.println("李斯，报告，韩非子有活动了-->"+reportContext);
	}
}

&

public class WangSi 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 LiuSi 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+"，--所以我快乐呀!");
	}
}

6. 场景类

public class Client {
	public static void main(String[] args) throws InterruptedException {
		//定义三个观察者
		Observer liSi = new LiSi();
		Observer wangSi = new WangSi();
		Observer liuSi = new LiuSi();
		//定义出韩非子
		HanFeiZi hanFeiZi = new HanFeiZi();
		//我们后人根据历史，描述这个场景，有三个人在观察韩非子
		hanFeiZi.addObserver(liSi);
		hanFeiZi.addObserver(liuSi);
		hanFeiZi.addObserver(wangSi);
		//然后，我们看韩非子在干什么
		hanFeiZi.haveBreakfast();
	}
}

三、观察者模式定义

观察者模式是，在项目中常用到的模式，用于定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

1）Subject被观察者

它必须可以动态增加、取消观察者。它一般是抽象类或者是实现类，仅仅完成作为被观察者必须实现的职责：管理观察者和通知观察者

2）Observer观察者

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

3）ConcreteSubject具体的被观察者

定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。

4）ConcreteObserver具体的观察者

每个观察者在接收到消息后处理反应是不同，各个观察者有自己的处理逻辑。

1. 被观察者

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 obs:obsVector){
			obs.update();
		}
	}
}

2. 具体被观察者

public class ConcreteSubject extends Subject{
	//具体的业务
	public void doSomething(){
		/*
		 * do something
		 */
		super.notifyObservers();
	}
}

3. 观察者

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

4. 具体观察者

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

5. 场景类

public class Client {
	private void mian() {
		//创建一个被观察者
		ConcreteSubject subject = new ConcreteSubject();
		//定义一个观察者
		Observer obs = new ConcreteObserver();
		//观察者观察被观察者（将观察者add到被观察者类中的List中）
		subject.addObserver(obs);
		//被观察者开始活动了
		subject.doSomething();
	}
}

四、观察者模式的（推模式 和 拉模式）

推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；

而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。 —— 工作中一般使用拉模式，因为可以拉取整个主题对象

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

观察者模式所涉及的角色有：

• 抽象主题(Subject)角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集（比如ArrayList对象）里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做抽象被观察者(Observable)角色。
• 具体主题(ConcreteSubject)角色：将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者(Concrete Observable)角色。
• 抽象观察者(Observer)角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。
• 具体观察者(ConcreteObserver)角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态 像协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。

观察者模式包含两种模式：推模式和拉模式

推模式：就好比发粮食，一个个的送到手。

拉模式：也好比发粮食，但是是先把抽象主体发送到观察者，由观察者角色自己按需取

两种模式的比较

• 推模型是假定主题对象知道观察者需要的数据；而拉模型是主题对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值。
• 推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。

抽象主题角色类

public abstract class ThemeObj {
	List<UsePeo> list = new ArrayList<UsePeo>();
	public void add(UsePeo up){
		list.add(up);
	}
	public void remove(UsePeo up){
		list.remove(up);
	}
	/*
	 * 推模式
	 */
	public void updateCall(String msg){
		for(int i = 0;i < list.size();i++){
			UsePeo up = list.get(i);
			up.update(msg);
		}
	}
	/*
	 * 拉模式
	 */
	public void updateCall2(){
		for(UsePeo up:list){
			up.update(this);
		}
	}
}

具体主题角色类

public class ThemeObjImpl extends ThemeObj{
	String msg;
	public String getMsg() {
		return msg;
	}
	/*
	 * 推模式
	 */
	public void updateLoad(String msgNew){
		msg=msgNew;
		updateCall(msgNew);
		System.out.println("已发出新信息");
	}
	/*
	 * 拉模式
	 */
	public void updateLoad2(String msgNew){
		msg = msgNew;
		System.out.println("新信息为:"+msg);
		updateCall2();
	}
}

抽象观察者角色类

public interface UsePeo {
	/*
	 * 推模式
	 */
	public void update(String msg);
	/*
	 * 拉模式
	 */
	public void update(ThemeObj to);
}

具体观察者角色类

public class UsePeoImpl implements UsePeo {
	String msg;
	/*
	 * 推模式
	 */
	@Override
	public void update(String msg) {
		msg=msg;
		System.out.println("已成功更新:"+msg);
	}
	/*
	 * 拉模式
	 */
	@Override
	public void update(ThemeObj to) {
		msg = ((ThemeObjImpl)to).getMsg();
		System.out.println("观察者信息为:"+msg);
	}
}

客户端类

public class Test {
	public static void main(String[] args) {
		//创建主题对象  
		ThemeObjImpl toi = new ThemeObjImpl();
		//创建观察者对象  
		UsePeo up = new UsePeoImpl();
		//将观察者对象登记到主题对象上  
		toi.add(up);
		//改变主题对象的状态  
		toi.updateLoad("msgmsgNew");	//推模式
		toi.updateLoad2("msgmsgNew");	//拉模式
	}
}

五、观察者模式的应用

1. 优点

1）观察者和被观察者之间是抽象耦合：不管是增加观察者不是被观察者都非常容易扩展。

2）建立一套触发机制

2. 缺点

一个被观察者，多个观察者，开发和调试比较复杂，而且在Java中消息的通知默认是顺序执行，一个观察者卡壳，会影响整体执行效率，这种情况下一般考虑采用异步方式。

3. 使用场景 

1）关联行为场景，需要注意的是，关联行为是可以拆分的，而不是组合关系。

2）事件多级触发场景

3）跨系统的消息交换场景，如消息队列 的处理机制

4.注意事项

使用时，注意广播链的问题，根据经验建议，在一个观察者模式中最多出现一个对象即是观察者也是被观察者，也就是说消息最多转发一次（传递两次）

六、观察者模式扩展

1. Java世界中的观察者模式

其实在Java中提供了java.util.Observable和java.util.Observer

修改后的类图如下：

优化后的被观察者

public class HanFeiZi extends Observable implements IHanFeiZi {
	//韩非子要吃饭了
	public void haveBreakfast() {
		System.out.println("韩非子开始吃饭...");
		//通知所有观察者
		super.setChanged();
		super.notifyObservers("韩非子在吃饭...");
	}
	//韩非子要娱乐了
	public void haveFun() {
		System.out.println("韩非子开始娱乐...");
		//通知所有观察者
		super.setChanged();
		super.notifyObservers("韩非子在娱乐...");
	}
}

改变得不多，引入了一个java.util.Observable对象，删除了增加、删除观察者的方法，简单很多

优化后的观察者

public class LiSi implements Observer{
	//首先李斯是个观察者，一旦韩非子有活动，他就知道，他就要向老板汇报
	public void update(Observable o, Object arg) {
		System.out.println("李斯，观察到韩非子活动，开始向老板汇报了");
		this.reportToQinShiHuang(arg.toString());
		System.out.println("李斯，汇报完了..");
	}
	//李斯报告秦始皇
	public void reportToQinShiHuang(String reportContext){
		System.out.println("李斯，报告，韩非子有活动了-->"+reportContext);
	}
}

java.util.Observer接口要求update传递过来两个变量，Observable这个变量我们没有用到（接口中定义必须实现的），就不必处理了。场景类没有改动，运行结果相同

2. 项目中真实的观察者模式

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

被观察者状态改变会触发观察者的一个行为，同时传递一个消息给观察者，这是正确的，在实际中一般是，观察者中的update方法接受两个参数，一个是被观察者，一个是DTO（JavaBean），由观察者消费。

2）观察者响应方式

如果观察者处理逻辑比较复杂，可以采用多线程技术，也就是异步架构。二是缓存技术，代价是开发难度大，而且东风来了测试要做的足够充分，也就是同步架构。

七、最佳实践

1. 文件系统

比如一个目录下新建立一个文件，这个动作会同时通知目录管理器增加该目录，并通知磁盘管理器减少1KB的空间，也就说“文件”是一个被观察者，“目录管理器”和“磁盘管理器”则是观察者。

2. 猫鼠游戏

夜里猫叫了一声，老鼠撒腿就跑，吵醒了熟睡的主人，这个场景中，“猫”就是被观察者，老鼠和人则是观察者

3. ATM取钱

ATM机器取钱，多次输错密码，卡就会被ATM吞了，吞卡运用发生时，会触发哪些事件呢？第一，摄像头连续快拍，第二，通知监控系统吞卡发生，第三，初始化系统，返回最初状态，一般前两个动作是通过观察者模式来完成的，后一个运用是异常来完成的。