观察者设计模式从无到有
Posted hymKing
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了观察者设计模式从无到有相关的知识，希望对你有一定的参考价值。
声明： ①此篇博文参照《设计模式之禅》，并对其中的demo场景做了相应的修改 ②此篇博文是分析观察者设计模式的从无到有。其中有四个版本的代码的演进，另外还包括java jdk提供的Obsevable.java 和Obsever.java的使用的一个版本以及对其源码的简单分析。 ③如果只想使用ava jdk的观察者api，直接看demo源码中com.hym.observe;如果想自定义观察者设计模式的应用 直接看demo源码中的com.hym.myobserve4 ④不能为了设计模式而使用设计模式，模式的使用一定是符合业务场景或者代码优化的需要，是为解决问题而生的强烈建议：看四个版本的演进过程。这四个版本分别解决了不同的问题，涉及一些软件工程的设计思想，比如开闭原则 单一职责原则等。
代码编写场景：
|
韩非子和李斯的间谍故事
李斯是秦国的上尉，需要安插间谍到各个国家，以便获取信息。韩非子做为韩国的重量级人物，韩非子身边自然 有很多间谍。李斯对韩非子的信息，了如指掌，那么相隔千里，是如何实现的呢？ 答案：安插间谍。 |
package com.hym.myobserve;
/**
* 测试主程
* */
public class Client
public static void main(String[] args) throws InterruptedException
LiSi liSi=new LiSi();
HanFeiZi hanFeiZi=new HanFeiZi();
//观察吃早餐
Spy watchBreakfast=new Spy(hanFeiZi, liSi, "breakfast");
//观察娱乐
Spy watchFun=new Spy(hanFeiZi, liSi, "fun");
//此处的问题//
//开启了两个线程，两个线程开启了两个死循环，一直在执行实现监控
//这样会比较消耗cpu的资源。
/
watchBreakfast.start();
watchFun.start();
//主线程等待1s韩非子吃饭
Thread.sleep(1000);
hanFeiZi.haveBreakfast();
Thread.sleep(1000);
hanFeiZi.haveFun();
IHanFeiZi.java:
public interface IHanFeiZi
/**吃早饭*/
public void haveBreakfast();
/**娱乐活动*/
public void haveFun();
HanFeiZi.java：
package com.hym.myobserve;
/**
*韩非子类，继承韩非子接口，添加两个标示状态的属性
* */
public class HanFeiZi implements IHanFeiZi
private boolean isHaveBreakfast=false;
private boolean isHaveFun=false;
@Override
public void haveBreakfast()
System.out.println("韩非子：开始吃饭啦");
isHaveBreakfast=true;
@Override
public void haveFun()
System.out.println("韩非子：开始娱乐了");
isHaveFun=true;
public boolean isHaveBreakfast()
return isHaveBreakfast;
public void setHaveBreakfast(boolean isHaveBreakfast)
this.isHaveBreakfast = isHaveBreakfast;
public boolean isHaveFun()
return isHaveFun;
public void setHaveFun(boolean isHaveFun)
this.isHaveFun = isHaveFun;
ILisi.java:
/**
*
* 抽象观察者对象李斯
* */
public interface ILisi
/**发现别人有动静，自己也要行动起来*/
public void update(String context);
Lisi.java：
package com.hym.myobserve;
/**
* 观察者对象李斯
* */
public class LiSi implements ILisi
//李斯是个观察者对象，一旦发现情况，需要要boss进行汇报
@Override
public void update(String context)
System.out.println("李斯观察到韩非子有活动了，并向秦始皇汇报");
reportToQinShiHuang(context);
System.out.println("李斯报告秦始皇:汇报完毕");
private void reportToQinShiHuang(String reportContext)
System.out.println("李斯报告秦始皇:韩非子有活动了---->"+reportContext);
Spy.java:
package com.hym.myobserve;
/**
* 间谍程序，监控程序是一个线程类
* */
public class Spy extends Thread
private HanFeiZi hanFeiZi;
private LiSi liSi;
private String type;
/**通过构造函数，构造谁被观察，观察谁，观察什么*/
public Spy(HanFeiZi hanFeiZi,LiSi liSi,String type)
this.hanFeiZi=hanFeiZi;
this.liSi=liSi;
this.type=type;
@Override
public void run()
//用死循环来保证程序一直在监控状态
while(true)
//监控是否在吃早餐
if(this.type.equals("breakfast"))
if(hanFeiZi.isHaveBreakfast())
this.liSi.update("韩非子在吃饭");
this.hanFeiZi.setHaveBreakfast(false);
else//监控是否在娱乐
if(hanFeiZi.isHaveFun())
this.liSi.update("韩非子在娱乐");
this.hanFeiZi.setHaveFun(false);
这样spy类就没有用了，修改成韩非子的对象中持有李斯对象的引用，通过业务代码直接实现间谍的作用。 com.hym.myobserve2为改进实现版 ，为实现版本的第二版
二. com.hym.myobserve2实现 场景中去掉了间谍。 主程client.java:
public class Client
public static void main(String[] args) throws InterruptedException
//定义韩非子
HanFeiZi hanFeiZi=new HanFeiZi();
//韩非子吃饭
hanFeiZi.haveBreakfast();
//韩非子娱乐
hanFeiZi.haveFun();
//==>主程类非常简单，但是发现李斯都没有在主程中声明。而是随着韩非子的上场而上场的。
//但是这是不符合场景的，就好比一部电视剧一样，不是所欲相关联的人物，从第一集就都要
//上场，而且建立关系。所以有第三个版本的改造。
IHanFeiZi.java:
public interface IHanFeiZi
/**吃早饭*/
public void haveBreakfast();
/**娱乐活动*/
public void haveFun();
HanFeiZi.java：
package com.hym.myobserve2;
import java.awt.List;
/**
*韩非子类，继承韩非子接口，添加两个标示状态的属性
* */
public class HanFeiZi implements IHanFeiZi
//声明李斯
private ILisi lisi=new LiSi();
@Override
public void haveBreakfast()
System.out.println("韩非子：开始吃饭啦");
lisi.update("韩非子在吃饭");
@Override
public void haveFun()
System.out.println("韩非子：开始娱乐了");
lisi.update("韩非子在娱乐");
ILisi.java:
/**
*
* 抽象观察者对象李斯
* */
public interface ILisi
/**发现别人有动静，自己也要行动起来*/
public void update(String context);
Lisi.java：
package com.hym.myobserve2;
/**
* 观察者对象李斯
* */
public class LiSi implements ILisi
//李斯是个观察者对象，一旦发现情况，需要要boss进行汇报
@Override
public void update(String context)
System.out.println("李斯观察到韩非子有活动了，并向秦始皇汇报");
reportToQinShiHuang(context);
System.out.println("李斯报告秦始皇:汇报完毕");
private void reportToQinShiHuang(String reportContext)
System.out.println("李斯报告秦始皇:韩非子有活动了---->"+reportContext);
优点：将观察者李斯和被观察者韩非子直接建立关系，直接触发观察者的更新。无死循环的spy类了
缺点：主程类非常简单，但是发现李斯都没有在主程中声明。而是随着韩非子的上场而上场的。 但是这是不符合场景的，就好比一部电视剧一样，不是所欲相关联的人物，从第一集就都要上 场，而且建立关系。所以有第三个版本的改造。
上述这种方式，是韩非子（被观察者）和李斯（观察者）之间存在较强的依赖，耦合性太强
优化：让被观察者和被观察者的关系建立的时机独立化。
三. com.hym.myobserve3实现
主程client.java:
package com.hym.myobserve3;
/**
* 测试主程
*
* */
public class Client
/**韩非子生活的总次数*/
private static int sum=0;
public static void main(String[] args) throws InterruptedException
// 定义韩非子
HanFeiZi hanFeiZi = new HanFeiZi();
startHanFeiziLive(hanFeiZi,2);
//韩非子生活了一段时间李斯出现了，并且开始监控
System.out.println("李斯开始监控韩非子");
LiSi liSi = new LiSi();
//设置监控
hanFeiZi.setILisi(liSi);
//韩非子被监视（观察）过后的一段生活
startHanFeiziLive(hanFeiZi,3);
//突然某一天秦王就把李斯给啥了
kill(liSi,hanFeiZi);
startHanFeiziLive(hanFeiZi,2);
System.out.println("韩非子一共娱乐或吃放了"+sum+"次");
/**
*
* @param hanFeiZi
* @param count 娱乐和吃饭的总次数
* @throws InterruptedException
*/
private static void startHanFeiziLive(HanFeiZi hanFeiZi,int count)
throws InterruptedException
// 为模拟业务，此处用循环来模拟李斯10次吃饭和10次娱乐
for (int i = 0; i < count; i++)
sum++;
// 前10次i是偶数的时候李斯吃饭
if (i < count/2)
// 后10次i是奇数的时候李斯吃饭
if (i % 2 == 0)
// 韩非子吃饭
hanFeiZi.haveBreakfast(sum);
else
hanFeiZi.haveFun(sum);
else
// 后10次i是奇数的时候李斯吃饭
if (i % 2 == 1)
// 韩非子吃饭
hanFeiZi.haveBreakfast(sum);
else
hanFeiZi.haveFun(sum);
Thread.sleep(1000 * 2);
/**
* 李斯被杀害
* @param lisi
*/
public static void kill(ILisi lisi,HanFeiZi hanFeiZi)
lisi=null;
//韩非子不能再持有lisi的应用，否则java回收机制不能及时回收lisi实例
hanFeiZi.setILisi(null);//实际开发中可以提供remove方法
IHanFeiZi.java:
public interface IHanFeiZi
/**吃早饭*/
public void haveBreakfast(int i);
/**娱乐活动*/
public void haveFun(int i);
HanFeiZi.java：
/**
* 韩非子类，继承韩非子接口，添加两个标示状态的属性
* */
public class HanFeiZi implements IHanFeiZi
// 为了让李斯的对象不是随着HanFeiZi对象的创建而创建，所以不能直接创建对象
// 而是在李斯对象在实际业务中被创建的时候，让韩非子对象才真正持有李斯对象
// 所以使用全部变量和set方法实现
// private ILisi lisi=new LiSi();
private ILisi mILisi;
public void setILisi(ILisi lisi)
mILisi = lisi;
@Override
public void haveBreakfast(int time)
System.out.println("韩非子：开始吃饭啦"+time);
if (mILisi != null)
mILisi.update("韩非子在吃饭");
@Override
public void haveFun(int time)
System.out.println("韩非子：开始娱乐了"+time);
if (mILisi != null)
mILisi.update("韩非子在娱乐");
ILisi.java:
public interface ILisi
/**发现别人有动静，自己也要行动起来*/
public void update(String context);
Lisi.java：
public class LiSi implements ILisi
//李斯是个观察者对象，一旦发现情况，需要要boss进行汇报
@Override
public void update(String context)
System.out.println("李斯观察到韩非子有活动了，并向秦始皇汇报");
reportToQinShiHuang(context);
System.out.println("李斯报告秦始皇:汇报完毕");
private void reportToQinShiHuang(String reportContext)
System.out.println("李斯报告秦始皇:韩非子有活动了---->"+reportContext);
第三个版本我们把业务场景变化一下：
|
韩非子其实一直就具备吃饭和娱乐的能力，只是在很长一段时间，没有被李斯监视（观察）过。
突然秦国觉得李斯这个人很重要，于是李斯这么个人要观察韩非子的行为，从而告知秦王。
|
第三版的实现运行后的场景表现： 韩非子：开始吃饭啦1 韩非子：开始吃饭啦2 李斯开始监控韩非子 韩非子：开始吃饭啦3 李斯观察到韩非子有活动了，并向秦始皇汇报 李斯报告秦始皇:韩非子有活动了---->韩非子在吃饭 李斯报告秦始皇:汇报完毕 韩非子：开始吃饭啦4 李斯观察到韩非子有活动了，并向秦始皇汇报 李斯报告秦始皇:韩非子有活动了---->韩非子在吃饭 李斯报告秦始皇:汇报完毕 韩非子：开始娱乐了5 李斯观察到韩非子有活动了，并向秦始皇汇报 李斯报告秦始皇:韩非子有活动了---->韩非子在娱乐 李斯报告秦始皇:汇报完毕 韩非子：开始吃饭啦6 韩非子：开始吃饭啦7 韩非子一共娱乐或吃放了7次
上述打印结果也说明了，观察者，可以在任意时刻开始观察，也可以在任意时刻不在观察。
对于韩非子和李斯这件事情的场景看似已经很完美了。
缺点：随着韩非子的历史地位越来越重要，想要观察韩非子活动的人越来越多。而且想要观察的行为也可能增多。 这时候，基于第三版，是不是我要每次都set观察者，然候韩非子的行为发生已有，要调用很多不同的观察者的 update的方法。如下： lisi.update; wangsi.update; ... 这样每次添加新的观察者的时候，都要去修改HanFeiZi类。 软件工程中的开闭原则： 遵循开闭原则设计出的模块具有两个主要特征：[1] （1）对于扩展是开放的（Open for extension）。这意味着模块的行为是可以扩展的。当应用的需求改变时，我 们可以对模块进行扩展，使其具有满足那些改变的新行为。也就是说，我们可以改变模块的功能。 （2）对于修改是关闭的（Closed for modification）。对模块行为进行扩展时，不必改动模块的源代码或者二 进制代码。模块的二进制可执行版本，无论是可链接的库、DLL或者.EXE文件，都无需改动。
所以当上面这种场景出现的时候，不仅代码上显得冗余，同时也违背软件工程设计的开闭原则。
优化方案：那么对上述场景的优化方案，需要满足两个条件，才算是合理的优化。 即 ①可以对现有的模块进行扩展（添加新的观察者） ②不需要去修改被观察者源代码。
那么实现版本的第四个版本来解决上述问题。
四. com.hym.myobserve4实现
那么在第三个版本中，主要违背开闭原则的地方，就是添加新的观察者的时候，李斯的对象内部，必须添加多个观察 者对象的update方法，来实现观察者被被观察者触发的行为。
思考：解决上述问题 ①通过现有的模块进行扩展，接口的思想（面向接口编程，抽象耦合） ②多个观察者出现的时候，无需修改被观察者的源码，通过持有集合的方式解决
具体看com.hym.myoberve4 添加IObserver接口,新的观察者实现此接口。 添加IObservable接口，新的被观察者实现此接口。
主程Client.java：
package com.hym.myobserve4;
/**
* 测试主程
*
* */
public class Client
/**韩非子生活的总次数*/
private static int sum=0;
public static void main(String[] args) throws InterruptedException
// 定义韩非子
HanFeiZi hanFeiZi = new HanFeiZi();
startHanFeiziLive(hanFeiZi,2);
//韩非子生活了一段时间李斯出现了，并且开始监控
System.out.println("李斯开始监控韩非子");
LiSi liSi = new LiSi();
//设置监控
hanFeiZi.addObsever(liSi);
//韩非子被监视（观察）过后的一段生活
startHanFeiziLive(hanFeiZi,3);
//突然某一天秦王就把李斯给杀了
kill(liSi,hanFeiZi);
startHanFeiziLive(hanFeiZi,2);
System.out.println("韩非子一共娱乐或吃放了"+sum+"次");
//场景中有了新的业务，秦国的李斯被杀过后，大王派王思观察HanFeizi的吃饭娱乐行为，
//同时要观察HanFeiZi是否有把妹行为。
WangSi wangSi=new WangSi();
hanFeiZi.addObsever(wangSi);
hanFeiZi.baMeizi();
//扩展新的观查者，对被观察的行为进行扩展都非常方便，而且观察者和被观察者的通用接口
//无需做任何修改，代码维护和扩展都很便捷，符合了软件设计中遵循的开闭原则
/**
*
* @param hanFeiZi
* @param count 娱乐和吃饭的总次数
* @throws InterruptedException
*/
private static void startHanFeiziLive(HanFeiZi hanFeiZi,int count)
throws InterruptedException
// 为模拟业务，此处用循环来模拟李斯10次吃饭和10次娱乐
for (int i = 0; i < count; i++)
sum++;
// 前10次i是偶数的时候李斯吃饭
if (i < count/2)
// 后10次i是奇数的时候李斯吃饭
if (i % 2 == 0)
// 韩非子吃饭
hanFeiZi.haveBreakfast(sum);
else
hanFeiZi.haveFun(sum);
else
// 后10次i是奇数的时候李斯吃饭
if (i % 2 == 1)
// 韩非子吃饭
hanFeiZi.haveBreakfast(sum);
else
hanFeiZi.haveFun(sum);
Thread.sleep(1000 * 2);
/**
* 李斯被杀害
* @param lisi
*/
public static void kill(IObserver lisi,HanFeiZi hanFeiZi)
System.out.println("======观察者李斯被杀害========");
//韩非子不能再持有lisi的引用，否则java回收机制不能及时回收lisi实例
//hanFeiZi.setILisi(null);//实际开发中可以提供remove方法
hanFeiZi.mIObservers.remove(lisi);
lisi=null;
IHanFeiZi.java:
public interface IHanFeiZi
/**吃早饭*/
public void haveBreakfast(int i);
/**娱乐活动*/
public void haveFun(int i);
HanFeiZi.java：
package com.hym.myobserve4;
import java.util.ArrayList;
import java.util.List;
/**
* 韩非子类，继承韩非子接口，添加两个标示状态的属性
**/
public class HanFeiZi implements IObservable,IHanFeiZi
// 为了让李斯的对象不是随着HanFeiZi对象的创建而创建，所以不能直接创建对象
// 而是在李斯对象在实际业务中被创建的时候，让韩非子对象才真正持有李斯对象
// 所以使用全部变量和set方法实现
// private ILisi lisi=new LiSi();
List<IObserver> mIObservers= new ArrayList<IObserver>();
@Override
public void haveBreakfast(int time)
System.out.println("韩非子：开始吃饭啦"+time);
notifyObsevers("吃饭");
@Override
public void haveFun(int time)
System.out.println("韩非子：开始娱乐了"+time);
notifyObsevers("娱乐");
/**
* 添加了把妹的新能力，如果把妹能力通用，可以提到接口中去
*/
public void baMeizi()
System.out.println("韩非子正在把妹");
notifyObsevers("韩非子正在把妹");
@Override
public void addObsever(IObserver iObserver)
mIObservers.add(iObserver);
@Override
public void deleteObsever(IObserver iObserver)
mIObservers.remove(iObserver);
@Override
public void notifyObsevers(String context)
if (mIObservers != null&&mIObservers.size()>0)
for (IObserver iObserver : mIObservers)
iObserver.update("韩非子在"+context);
IObserver.java:
/**
*
* 抽象观察者对象李斯<br>
* 将接口修改为通用的观察者接口
*
* */
public interface IObserver
/**发现别人有动静，自己也要行动起来*/
public void update(String context);
Lisi.java：
package com.hym.myobserve4;
/**
* 观察者对象李斯
* */
public class LiSi implements IObserver
//李斯是个观察者对象，一旦发现情况，需要要boss进行汇报
@Override
public void update(String context)
System.out.println("李斯观察到韩非子有活动了，并向秦始皇汇报");
reportToQinShiHuang(context);
System.out.println("李斯报告秦始皇:汇报完毕");
private void reportToQinShiHuang(String reportContext)
System.out.println("李斯报告秦始皇:韩非子有活动了---->"+reportContext);
IObservable.java:
package com.hym.myobserve4;
/**
* 被观察者接口，这样将实际业务和观察者模型也实现了分离。
* 此接口提供被观察者相关功能的声明
*/
public interface IObservable
/**
* 给被观察者添加观察者对象
* @param iObserver
*/
public void addObsever(IObserver iObserver);
/**
* 给被观察者删除观察者对象
* @param iObserver
*/
public void deleteObsever(IObserver iObserver);
/**
* 通知所有观察者，触发观察者行为
* @param context
*/
public void notifyObsevers(String context);
Wangsi.java：
public class WangSi implements IObserver
@Override
public void update(String context)
System.out.println(context);
上述过程就是观察者设计模式代码演进的过程，在java jdk中已经提供了相关的api
五.com.hym.observe Client.java：
/**
* 测试主程
*
* */
public class Client
public static void main(String[] args) throws InterruptedException
ObservableModle observableModle=new ObservableModle();
ObserverModle observerModle=new ObserverModle();
observableModle.addObserver(observerModle);
observableModle.doSometing("做一些事情..");
ObservableMoudle.java:
package com.hym.observe;
import java.util.Observable;
import java.util.Observer;
/**
*
* @description：
* <p>
* 可被观察的模型，模式的运用场景分析
* </p>
* @author： HuYuMian
*
* @QQ：732476506
*/
public class ObservableModle extends Observable
@Override
public synchronized void addObserver(Observer o)
super.addObserver(o);
@Override
public synchronized void deleteObserver(Observer o)
super.deleteObserver(o);
@Override
public void notifyObservers()
super.notifyObservers();
public void doSometing(String context)
System.out.println("被观察者"+context);
/*if (!changed)
return;
*/
//上面这部分代码在observable.java的源码中，有判断处理。默认值是false，不执行update方法。
//所以使用java本身的observable.java的api，通知观察者对象update方法调用，必须先执行setChanged
//方法，并在执行notifyObservers方法后，会被重置，调用protected synchronized void clearChanged()
//changed = false;
//
setChanged();
notifyObservers(context);
ObserverMoudle .java：
public class ObserverModle implements Observer
//参数说明：Observable o：被观察者对象
//Object arg:数据对象
@Override
public void update(Observable o, Object arg)
System.out.println("观察者"+arg.toString());
//相关源码的分析 jdk中的observable中使用vector存储观察者对象。 jdk中，notifyObsevers方法调用之前，使用setChanged，在代码注释中已有体现。 其余的基本上思路是一致的。
一些总结： 观察者模式的应用 1.观察者模式的优点： ①观察者和被观察者之间是抽象耦合。 观察者中通知行为，依赖于IObsever接口。而不依赖于某一具体的观察者对象。
耦合有三种： a.零耦合 实际业务中无关 b.具体耦合 类与类之间有依赖关系，一个类中，持有另一个具体类的应用 c.抽象耦合 这种关系发生在一个具体类和一个抽象类或者接口之间，这样就使 必须发生关系的类之间保持最大的灵活性。
所以提倡面向接口编程。
②建立一套触发机制 可以设计既是观察者有是被观察者的实际类，来实现一套流程的触发机制。 ------------------------------------------------------------------------------- 2.观察者设计模式的缺点 java的消息通知默认是顺序执行，一个观察者卡壳，会影响整体的执行效率。 ------------------------------------------------------------------------------- 3.观察者使用场景 ①关联行为场景。需要注意的是，关联行为是可拆分的，而不是“组合关系”。 ②事件多级触发 ③扩系统的消息交换场景，如消息队列的处理机制 -------------------------------------------------------------------------------
在android 开发中也有很多基于观察者设计模式的应用。 比如一些事件总线的框架： https://github.com/greenrobot/EventBus http://square.github.io/otto/ https://github.com/ReactiveX/RxAndroid
我只使用过EventBus，后期准备尝试RxAndroid
另外，listview的适配器数据更新，或者自己业务中需要处理的一些场景，使用观察者设计模式都能进行更好的解决
附上我的设计模式的os git上的地址： http://git.oschina.net/hymKing/DesignPatterns
啰嗦一句：想要更好的使用观察者设计模式来解决实际开发中遇到的问题，或者优化现有代码的扩展性和维护性，需要 在开发的过程之中，多思考。在必要的时候，使用它，能够事半功倍。
与50位技术专家面对面
20年技术见证，附赠技术全景图
以上是关于观察者设计模式从无到有的主要内容，如果未能解决你的问题，请参考以下文章