设计模式笔记--观察者模式

常用设计模式有23中，分为：

创建型模式（主要用于创建对象）

1、单例模式    2、工厂方法模式    3、抽象工厂模式    4、建造者模式     5、原型模式 
行为型模式 （主要用于描述对象或类是怎样交互和怎样分配职责）

1、模板方法模式  2、中介者模式  3、命令模式    4、责任链模式   5、策略模式   6、迭代器模式  

7、观察者模式      8、备忘录模式   9、访问者模式   10、状态模式   11、解释器模式

结构型模式(主要用于处理类或对象的组合)

1、代理模式  2、装饰模式   3、适配器模式   4、组合模式   5、外观模式（门面模式）   6、享元模式    7、桥梁模式

观察者模式

观察者模式（Observer Pattern）也叫做发布订阅模式（Publish/subscribe）,它是一个在项目中经常使用的模式，其定义如下：  

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

观察者模式的几个角色名称：

● Subject被观察者

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

● Observer观察者

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

● ConcreteSubject具体的被观察者

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

● ConcreteObserver具体的观察者

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

通用代码

先看被观察者角色，如代码清单22-15所示。

代码清单22-15 被观察者
public abstract class Subject {
//定义一个观察者数组
private Vector obsVector = new Vector();
//增加一个观察者
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();
}
}
}

被观察者的职责非常简单，就是定义谁能够观察，谁不能观察，程序中使用ArrayList和 Vector没有太大的差别， ArrayList是线程异步，不安全； Vector是线程同步，安全 ——就这点 区别。

具体的被观察者，如代码清单22-16所示。

代码清单22-16 具体被观察者
public class ConcreteSubject extends Subject {
//具体的业务
public void doSomething(){
/*
* do something
*/
super.notifyObservers();
}
}

我们现在看到的是一个纯净的观察者，在具体项目中该类有很多的变种，

我们再来看观察者角色，如代码清单22-17所示。

代码清单22-17 观察者
public interface Observer {
//更新方法
public void update();
}

观察者一般是一个接口，每一个实现该接口的实现类都是具体观察者，如代码清单22-18所示。

代码清单22-18 具体观察者
public class ConcreteObserver implements Observer {
//实现更新方法
public void update() {
System.out.println("接收到信息，并进行处理！");
}
}

那其他模块是怎么来调用的呢？我们编写一个Client类来描述，如代码清单22-19所示。

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

优点   

● 观察者和被观察者之间是抽象耦合  

● 建立一套触发机制  

缺点   

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

多级触发时的效率更是让人担忧，大家在设计时注意考虑。

使用场景  

● 关联行为场景。需要注意的是，关联行为是可拆分的，而不是“组合”关系。  

● 事件多级触发场景。

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

实例   韩非子间谍

在Observable接口中有三个比较重要的方法，分别是addObserver增加观察者，deleteObserver删除观察者，notifyObservers通知所有的观察者，

这是什么意思呢？我这里有一个信息，一个对象，我可以允许有多个对象来察看，你观察也成，我观察也成，只要是观察者就成，也就是说我的改变或动作执行，会通知其他的对象，

先看Observable接口，如代码清单22-9所示。

代码清单22-9 被观察者接口
public interface Observable {
//增加一个观察者
public void addObserver(Observer observer);
//删除一个观察者
public void deleteObserver(Observer observer);
//既然要观察，我发生改变了他也应该有所动作，通知观察者
public void notifyObservers(String context);
}

这是一个通用的被观察者接口，所有的被观察者都可以实现这个接口。

再来看韩非子的实现类，如代码清单22-10所示。

代码清单22-10 被观察者实现类
public class HanFeiZi implements Observable ,IHanFeiZi{
//定义个变长数组，存放所有的观察者
private ArrayList observerList = new ArrayList();
//增加观察者
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 observer:observerList){
observer.update(context);
}
}
//韩非子要吃饭了
public void haveBreakfast(){
System.out.println("韩非子:开始吃饭了...");
//通知所有的观察者
this.notifyObservers("韩非子在吃饭");
}
//韩非子开始娱乐了
public void haveFun(){
System.out.println("韩非子:开始娱乐了...");
this.notifyObservers("韩非子在娱乐");
}
}

观察者接口，如代码清单22-11所示。

代码清单22-11 观察者接口
public interface Observer {
//一发现别人有动静，自己也要行动起来
public void update(String context);
}

然后是三个很无耻的观察者，咱先看看真实的李斯，如代码清单22-12所示。

代码清单22-12 具体的观察者
public class LiSi implements Observer{
//首先李斯是个观察者，一旦韩非子有活动，他就知道，他就要向老板汇报
public void update(String str){
System.out.println("李斯：观察到韩非子活动，开始向老板汇报了...");
this.reportToQinShiHuang(str);
System.out.println("李斯：汇报完毕...\n");
}
//汇报给秦始皇
private void reportToQinShiHuang(String reportContext){
System.out.println("李斯：报告，秦老板！韩非子有活动了-->"+reportContext);
}
}

李斯是真有其人，以下两个观察者王斯和刘斯是杜撰出来的，如代码清单22-13所示。

代码清单22-13 杜撰的观察者
public class WangSi implements Observer{
//王斯，看到韩非子有活动
public void update(String str){
System.out.println("王斯：观察到韩非子活动，自己也开始活动了...");
this.cry(str);
System.out.println("王斯：哭死了...\n");
}
//一看韩非子有活动，他就痛哭
private void cry(String context){
System.out.println("王斯：因为"+context+"，--所以我悲伤呀！");
}
}

public class LiuSi implements Observer{
//刘斯，观察到韩非子活动后，自己也得做一些事
public void update(String str){
System.out.println("刘斯：观察到韩非子活动，开始动作了...");
this.happy(str);
System.out.println("刘斯：乐死了\n");
}
//一看韩非子有变化，他就快乐
private void happy(String context){
System.out.println("刘斯：因为" +context+",--所以我快乐呀！" );
}
}

所有的人物都在场了，那我们来看看这场历史闹剧是如何演绎的，如代码清单22-14所示。

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

符合开闭原则，同时也实现类间解耦  

注意事项  

● 广播链的问题  

根据经验建议，在一个观察者模式中最多出现一个对象既是观察者也是被观察者，也就是说消息最多转发一次（传递两次），这还是比较好控制的。  

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

● 异步处理问题  

异步处理就要考虑线程安全和队列的 问题   

观察者模式的扩展   

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

JDK中提供了:java.util.Observable实现类和java.util.Observer接口  

使用了Java提供的观察者模式后是不是简单了很多，所以在Java的世界里横行时，多看看API，有帮助很大，很多东西Java已经帮你设计了一个良好的框架。  

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

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

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

● 观察者响应方式  

● 被观察者尽量自己做主  

被观察者的状态改变是否一定要通知观察者呢？不一定吧，在设计的时候要灵活考虑，否则会加重观察者的处理逻辑，