设计模式之观察者设计模式

首先介绍我在实际开发过程中使用到的观察者模式：
在写一个Android应用商城的时候，下载某个App时可以在主页点击下载，也可以查看这个App详情页面下载.而无论点击那个下载链接来下载，它们两个下载的进度必须是同步的，这就需要两个观察者来观察下载这一个过程。
首先简单介绍一下观察者设计模式,包括java自带的观察者的接口与被观察者的抽象类.文章后面详细介绍观察者设置模式.
java的util包提供了Observable类与Observer接口。其中继承Observable的为被观察者，实现Observer接口的为观察者:
被观察者的代码:

public class DownLoadManage extends Observable{
    @Override
    //hasChanged必须重写，返回true表示改变了，才会通知观察者
    public boolean hasChanged() {
        return  true;
    }
}

观察者的示例代码:

public class ToSeeDownLoad1 implements Observer {
//实现接口的update的方法，当被观察者有动静时调用
    @Override
    public void update(Observable observable, Object o) {
        System.out.println("1看见你的变化");
    }
}

测试类：

 //观察者与被观察者
   DownLoadManage   downLoadManage = new DownLoadManage();
   //为被观察者注册观察者
    downLoadManage.addObserver(new ToSeeDownLoad1());
   downLoadManage.addObserver(new ToSeeDownLoad2());
//被观察者通知观察者
downLoadManage.notifyObservers();

如上就是观察者模式的简单案例,但这个有个很大的缺陷就是被观察者是继承了Observable抽象类，我们知道java只能单继承。所以java的util自动为我们提供的抽象类使用很局限。所以我们可以通过查看ObServable的源码来自己实现被观察者。

通过查看 源码可以知道，被观察者的ObServable其实内部维护了一个泛型为Observer(观察者的接口)的集合。当增加观察者时就向集合中增加对象，调用notifyObservers()方法时就是遍历集合的每个数据来调用接口中的update的方法。我们仿照这个逻辑来自己定义观察者的接口而改变被观察者继承ObServable的局限性。

被观察者的接口

public interface MyObserverInterface {
    //以后观察者实现这个接口
    void update();
}

被观察者:

public class DownLoadManageForMyObserver {
    List<MyObserverInterface> list = new ArrayList<MyObserverInterface>();
   //添加观察者
    public synchronized void addObServer(MyObserverInterface myObserverInterface){
        if(myObserverInterface==null){
            throw new NullPointerException();
        }else  if (!list.contains(myObserverInterface)) {
            list.add(myObserverInterface);
        }
    }
    //通知观察者数据改变了来调用观察者的update方法
    public  synchronized void notifyObServers(){
        for(MyObserverInterface myObserverInterface : list){
            myObserverInterface.update();
        }
    }
}

观察者:

public class MyToSeeDownLoad1 implements MyObserverInterface {
    @Override
    public void update() {
        System.out.println("1 see");
    }
}

测试类:

  //观察者与被观察者
    DownLoadManageForMyObserver    downLoadManageForMyObserver = new DownLoadManageForMyObserver();
        downLoadManageForMyObserver.addObServer(new MyToSeeDownLoad1());
         downLoadManageForMyObserver.notifyObServers();

经过修改之后，观察者的扩展性也更强了除了update()方法之外，也可以增加其他方法。最后只有在被观察者中调用就行。
现在我们从头到尾学习观察者设计模式:
参考书籍 ： 秦小波老师的《设计模式之禅》

案例:
以李斯(观察者)观察韩非子(被观察者)为例来说明:

被观察者接口
public interface IHanFeiZi {
//韩非子也是人,也要吃早饭的
public void haveBreakfast();
//韩非之也是人,是人就要娱乐活动
public void haveFun();
}

对接口进行扩充,增加了两个状态isHavingBreakfast(是否在吃早饭)和isHavingFun(是否在娱乐),以方便进行监控:

/*
具体的被观察者
*/
public class HanFeiZi implements IHanFeiZi{
//韩非子是否在吃饭,作为监控的判断标准
private boolean isHavingBreakfast = false;
//韩非子是否在娱乐
private boolean isHavingFun = false;
//韩非子要吃饭了
public void haveBreakfast(){
System.out.println("韩非子:开始吃饭了...");
this.isHavingBreakfast =true;
}
//韩非子开始娱乐了
public void haveFun(){
System.out.println("韩非子:开始娱乐了...");
this.isHavingFun = true;
}
//以下是bean的基本方法,getter/setter,不多说
public boolean isHavingBreakfast() {
return isHavingBreakfast;
}
public void setHavingBreakfast(boolean isHavingBreakfast) {
this.isHavingBreakfast = isHavingBreakfast;
}
public boolean isHavingFun() {
return isHavingFun;
}
public void setHavingFun(boolean isHavingFun) {
this.isHavingFun = isHavingFun;
}
}

通过isHavingBreakfast和isHavingFun这两个布尔型变量来判断韩非子是否在吃饭或者娱乐,韩非
子属于被观察者,那还有观察者李斯,我们来看李斯的接口

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

李斯这类人比较简单,一发现自己观察的对象发生了变化,比如吃饭、娱乐,自己立刻也要行动起来,怎么行动呢?

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

两个重量级的人物都定义出来了,间谍这个“卑鄙”小人是不是也要登台了,如代码清单：

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(this.hanFeiZi.isHavingBreakfast()){
this.liSi.update("韩非子在吃饭");
//重置状态,继续监控
this.hanFeiZi.setHavingBreakfast(false);
}
}else{//监控是否在娱乐
if(this.hanFeiZi.isHavingFun()){
this.liSi.update("韩非子在娱乐");
this.hanFeiZi.setHavingFun(false);
}
}
}
}
}

监控程序继承了java.lang.Thread类,可以同时启动多个线程进行监控,Java的多线程机制还是比较简单的,继承Thread类,重写run()方法,然后new SubThread(),再然后subThread.start()就可以启动一个线程了。我们建立一个场景类来回顾一下这段历史,如代码清单:

public class Client {
public static void main(String[] args) throws InterruptedException {
//定义出韩非子和李斯
LiSi liSi = new LiSi();
HanFeiZi hanFeiZi = new HanFeiZi();
//观察早餐
Watch watchBreakfast = new Watch(hanFeiZi,liSi,"breakfast");
//开始启动线程,监控
watchBreakfast.start();
//观察娱乐情况
Watch watchFun = new Watch(hanFeiZi,liSi,"fun");
watchFun.start();
//然后我们看看韩非子在干什么
Thread.sleep(1000); //主线程等待1秒后后再往下执行
hanFeiZi.haveBreakfast();
//韩非子娱乐了
Thread.sleep(1000);
hanFeiZi.haveFun();
}
}

运行结果如下所示:
韩非子:开始吃饭了…
李斯:观察到韩非子活动,开始向老板汇报了…
李斯:报告,秦老板!韩非子有活动了—>韩非子在吃饭
李斯:汇报完毕
韩非子:开始娱乐了…
李斯:观察到韩非子活动,开始向老板汇报了…
李斯:报告,秦老板!韩非子有活动了—>韩非子在娱乐
李斯:汇报完毕

按照如上的代码可以完成观察的需求。当通过一个while(true)的死循环来完全是不可取的，我们需要优化上述代码:
我们来想,既然韩非子一吃饭李斯就知道了,那我们为什么不把李斯这个类聚集到韩非子那个类上呢?

IHanFeiZi接口完全没有修改,我们来看实现类:

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("韩非子在娱乐");
}
}

韩非子HanFeiZi实现类就把接口的两个方法实现就可以了,在每个方法中调用
LiSi.update()方法,完成李斯观察韩非子的职责,李斯的接口和实现类都没有任何改变:我们再来看看Client程序的变更:

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

我们思考一下,修改后的程序运行结果正确,效率也比较高,是不是应该乐呵乐呵了?大功告成了?稍等等,你想在战国争雄的时候,韩非子这么有名望、有实力的人,就只有秦国关心他吗?想想也不可能呀,确实有一大帮的各国类似于李斯这样的人在看着他,监视着他的一举一动,但是看看我们的程序,你在HanFeiZi这个类中定义:

private ILiSi liSi =new LiSi();

这样一来只有李斯才能观察到韩非子,这是不对的,也就是说韩非子的活动只通知了李斯一个人,这不可能;再者说了,李斯只观察韩非子的吃饭、娱乐吗?政治倾向不关心吗?思维倾向不关心吗?杀人放火不关心吗?也就说韩非子的一系列活动都要通知李斯,这可怎么办?要按照上面的例子,我们如何修改?

我们在原来的基础上做了两个修改:
● 增加Observable
实现该接口的都是被观察者,那韩非子是被观察者,他当然也要实现该接口了,同时他
还有与其他庸人相异的事要做,因此他还是要实现IHanFeizi接口。
● 修改ILiSI接口名称为Observer
接口名称修改了一下,这样显得更抽象化,所有实现该接口的都是观察者(类似李斯这
样的)。

Observable是被观察者,就是类似韩非子这样的人,在Observable接口中有三个比较重要的方法,分别是addObserver增加观察者,deleteObserver删除观察者,notifyObservers通知所有的观察者,这是什么意思呢?我这里有一个信息,一个对象,我可以允许有多个对象来察看,你观察也成,我观察也成,只要是观察者就成,也就是说我的改变或动作执行,会通知其他的对象,看程序会更明白一点,先看Observable接口:

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

被观察者实现类

public class HanFeiZi implements Observable ,IHanFeiZi{
//定义个变长数组,存放所有的观察者
private ArrayList<Observer> observerList = new ArrayList<Observer>();
//增加观察者
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("韩非子在娱乐");
}
}

观察者只是把原有的ILiSi接口修改了一个名字而已,如代码清单22-11所示。

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

具体的观察者1

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

具体的观察者1

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+",--所以我悲伤呀!");
}
}

具体的观察者2

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+",--所以我快乐呀!" );
}
}

场景类

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

运行结果如下所示:
韩非子:开始吃饭了…
李斯:观察到韩非子活动,开始向老板汇报了…
李斯:报告,秦老板!韩非子有活动了—>韩非子在吃饭
李斯:汇报完毕…
王斯:观察到韩非子活动,自己也开始活动了…
王斯:因为韩非子在吃饭——所以我悲伤呀!
王斯:哭死了…
刘斯:观察到韩非子活动,开始动作了…
刘斯:因为韩非子在吃饭——所以我快乐呀!刘斯:乐死了

好了,结果也正确了,也符合开闭原则了,同时也实现类间解耦,想再加观察者?继续实现Observer接口就成了,这时候必须修改Client程序,因为你的业务都发生了变化。这就是观察者模式。