* 24种设计模式——观察者模式
核心：定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。
推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；
而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。 —— 工作中一般使用拉模式，因为可以拉取整个主题对象
一、只有李斯（观察者）监视韩非子（被观察者）
1. 被观察者接口
public interface IHanFeiZi {
//韩非子也是人，也要吃饭
public void haveBreakfast();
//韩非子也有娱乐活动
public void haveFun();
}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("韩非子在娱乐...");
}
}public interface ILiSi {
//一发现别人有动静，自己也要行动起来
public void update(String context);
}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);
}
}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();
}/**
* 实现该接口的都是被观察者
*/
public interface Observable {
//增加一个观察者
public void addObserver(Observer observer);
//删除一个观察者
public void deleteObserver(Observer observer);
//既然要观察，我发生改变了他也应该有所动作，通知观察者
public void notifyObservers(String context);
}/**
* 实现该接口的都是观察者
*/
public interface Observer {
//一发现别人有动静，自己也要行动起来
public void update(String context);
}public class HanFeiZi implements IHanFeiZi,Observable{
//定义个变长的数组，存放所有的观察者
private List observerList = new ArrayList();
//增加观察者
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("韩非子在娱乐...");
}
} 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+"，--所以我快乐呀!");
}
}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 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 obs:obsVector){
obs.update();
}
}
} public class ConcreteSubject extends Subject{
//具体的业务
public void doSomething(){
/*
* do something
*/
super.notifyObservers();
}
}public interface Observer {
//更新方法
public void update();
}public class ConcreteObserver implements Observer{
//实现更新方法
public void update() {
System.out.println("接收到信息，并进行处理!");
}
}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 list = new ArrayList();
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);
}
}2. 项目中真实的观察者模式
1）观察者和被观察者之间的消息沟通
被观察者状态改变会触发观察者的一个行为，同时传递一个消息给观察者，这是正确的，在实际中一般是，观察者中的update方法接受两个参数，一个是被观察者，一个是DTO（JavaBean），由观察者消费。
2）观察者响应方式
如果观察者处理逻辑比较复杂，可以采用多线程技术，也就是异步架构。二是缓存技术，代价是开发难度大，而且东风来了测试要做的足够充分，也就是同步架构。
七、最佳实践
1. 文件系统
比如一个目录下新建立一个文件，这个动作会同时通知目录管理器增加该目录，并通知磁盘管理器减少1KB的空间，也就说“文件”是一个被观察者，“目录管理器”和“磁盘管理器”则是观察者。
2. 猫鼠游戏
夜里猫叫了一声，老鼠撒腿就跑，吵醒了熟睡的主人，这个场景中，“猫”就是被观察者，老鼠和人则是观察者
3. ATM取钱
ATM机器取钱，多次输错密码，卡就会被ATM吞了，吞卡运用发生时，会触发哪些事件呢？第一，摄像头连续快拍，第二，通知监控系统吞卡发生，第三，初始化系统，返回最初状态，一般前两个动作是通过观察者模式来完成的，后一个运用是异常来完成的。