设计模式之观察者模式

观察者模式

Rxjava中运用到了观察者模式，那什么是观察者模式呢，现在来学习一下。正所谓观察，就是看，细察事物的现象、动向。在这里看来就是监视目标的动作,然后自己作出相应的回应。

先写一个简单的观察者

• 不可能只有一个观察者是吧，抽象一个观察者接口：

    public interface ObserverInterface {
        //观察者获取到情报要更新状态
        public void update(String context);
    }
  

• 定义一个观察者类：

    public class RealObserver implements ObserverInterface {
    
        @Override
        public void update(String context) {
            System.out.println("观察到对方动作,开始汇报");
            this.reportToBoss(context);
            System.out.println("汇报完毕");
        }
        
        //获取到情报要汇报
        public void reportToBoss(String context){
            System.out.println("老板,有情况。。。目标在" + context);
        }
    }
  

再写一个被观察者

• 抽象一些被观察者的行为。

    public interface ObservableInterface {
        //被观察者的动作
        public void eat();
        public void sleep();
    }
  

• 定义一个被观察者类：

    public class RealObservable implements ObservableInterface {
        
        private boolean isEat = false;
        private boolean isSleep = false;
        
        public boolean isEat() {
            return isEat;
        }
    
        public void setEat(boolean isEat) {
            this.isEat = isEat;
        }
    
        public boolean isSleep() {
            return isSleep;
        }
    
        public void setSleep(boolean isSleep) {
            this.isSleep = isSleep;
        }
    
        @Override
        public void eat() {
            System.out.println("我吃饭了。。。");
            this.isEat = true;
        }
    
        @Override
        public void sleep() {
            System.out.println("我睡觉了。。。");
            this.isSleep = true;
        }
    }
  

• 其中就是对两个布尔值的操作，同时还有get/set方法以便获取当前值并进行修改。

写一个线程类

既然要观察监视，就要时刻关注被观察者的状态，以便能在其发生改变的时候及时的更新自己的状态，那么我们就开一条子线程一直在其中循环判断嘛，这不就行了么。

public class WatchThread extends Thread {
    // 被观察者
    private RealObservable mRealObservable;
    // 观察者
    private RealObserver mReObserver;
    // 具体的监视事件
    private String mType;
    
    WatchThread(RealObservable realObservable ,RealObserver realObserver ,String type){
        this.mRealObservable = realObservable;
        this.mReObserver = realObserver;
        this.mType = type;
    }

    @Override
    public void run() {
        while (true) {
            if (this.mType.equals("eat")) {
                if (this.mRealObservable.isEat()){
                    this.mReObserver.update("吃饭。。。");
                    //重置状态,以便继续继续监视更新状态
                    this.mRealObservable.setEat(false);
                }
            } else {
                if (this.mRealObservable.isSleep()){
                    this.mReObserver.update("睡觉了。。。");
                    //重置状态,以便继续继续监视更新状态
                    this.mRealObservable.setSleep(false);
                }
            }
        }
    }
}

开启线程

那么现在，万事俱备，只欠东风。在主线程中，创建子线程，并开启线程，获取打印结果。

public static void main(String[] args) throws InterruptedException {
    //定义出观察者和被观察者
    RealObservable realObservable = new RealObservable();
    RealObserver realObserver= new RealObserver();
    
    //创建监视吃饭线程，并开启
    WatchThread eatWatch = new WatchThread(realObservable, realObserver, "eat");
    eatWatch.start();
    
    //创建监视睡觉线程，并开启
    WatchThread sleepWatch = new WatchThread(realObservable, realObserver, "sleep");
    sleepWatch.start();
    
    //主线程休眠1.5s,确保子线程开启完成
    Thread.sleep(1500);
    //改变被观察者状态
    realObservable.eat();
    
    Thread.sleep(1000);
    realObservable.sleep();
}

打印结果：</br>
我吃饭了。。。</br>
观察到对方动作,开始汇报</br>
老板,有情况。。。目标在吃饭。。。</br>
汇报完毕</br>
我睡觉了。。。</br>
观察到对方动作,开始汇报</br>
老板,有情况。。。目标在睡觉了。。。</br>
汇报完毕</br>

观察者的另一层含义

那么，这样并不算完，注意到没有，我们在子线程开一个无限死循环while(true)作监听，这样的成本太高。那应该如何进行修改呢，这里换一个方向想，我们需要的是什么，我们需要的是如果被观察者的状态发生了改变，或者说触发了什么事件，我们能够及时的获得这个情报，我们也只需要这个情报，想想看过的谍战片，一直派人监视目标是不是很累，并且需要大量的资源，就像这里的while(true)死循环一样，而有的人就买通目标身边的亲信，让亲信给自己送情报，一旦目标有什么动作就通知自己，这样是不是降低了很多成本，当然买通亲信也是要成本的咯。这也就成了观察者另外一层含义，古往今来从来不缺这类人，他有一个时髦的名称：间谍</br>
说了这么多，在代码中如何实现呢，让被观察者持有观察者的对象，在被观察者产生动作后，直接调用观察者的方法，就达到了汇报的目的了。

改进被观察者

• 让被观察者持有观察者对象，并在恰当的时机调用其方法。

    public class RealObservable implements ObservableInterface {
        //创建观察者对象
        private ObserverInterface mObserver = new RealObserver();
    
        @Override
        public void eat() {
            System.out.println("我吃饭了。。。");
            this.mObserver.update("吃饭了");
        }
    
        @Override
        public void sleep() {
            System.out.println("我睡觉了。。。");
            this.mObserver.update("睡觉了");
        }
    }
  

修改主函数

public static void main(String[] args) throws InterruptedException {
    //创建被观察者
    RealObservable realObservable = new RealObservable();
    realObservable.eat();
    realObservable.sleep();
}

运行打印结果：</br>
我吃饭了。。。</br>
观察到对方动作,开始汇报</br>
老板,有情况。。。目标在吃饭了</br>
汇报完毕</br>
我睡觉了。。。</br>
观察到对方动作,开始汇报</br>
老板,有情况。。。目标在睡觉了</br>
汇报完毕</br>

打印结果正确，同时效率也提高了。那么是不是这样就够了呢，想一想，我们难道只有一个观察者么，
被观察者的行为难道仅仅是“吃饭”，“睡觉”么，我们应该要达到想增加观察者或者删除观察者，一行代码就搞定的目的，这样的代码才方便后期的拓展和维护是吧。

改进被观察者接口

• 我们要控制对观察者的增加和删除，也就是要求在被观察者类中进行操作，那么抽象一个接口，里面定义增加观察者和删除观察者的方法。

    public interface ObservableInterface {
        //添加观察者
        public void addObserver(ObserverInterface observer);
        //移除观察者
        public void removeObserver(ObserverInterface observer);
        //通知观察者
        public void notifyObserver(String context);
    }
  

• 重新定义被观察者类：

    public class RealObservable implements ObservableInterface {
        private List<ObserverInterface> mObserverList = new ArrayList<ObserverInterface>();
        
        @Override
        public void addObserver(ObserverInterface observer) {
            mObserverList.add(observer);
        }
    
        @Override
        public void removeObserver(ObserverInterface observer) {
            mObserverList.remove(observer);
        }
    
        @Override
        public void notifyObserver(String context) {
            for (ObserverInterface observer : mObserverList) {
                observer.update(context);
            }
        }
        
        public void eat(){
            System.out.println("我吃饭了。。。");
            this.notifyObserver("吃饭了");
        }
        
        public void sleep(){
            System.out.println("我睡觉了。。。");
            this.notifyObserver("睡觉了");
        }
    }
  

• 为了让结果更直观，对观察者也作出适当的修改：

    public class RealObserver implements ObserverInterface {
        private String name = null;
        
        public RealObserver(String name){
            this.name = name;
        }
        
        @Override
        public void update(String context) {
            System.out.println("我是" + name + "观察到对方动作,开始汇报");
            this.reportToBoss(context);
            System.out.println("汇报完毕");
        }
        
        //获取到情报要汇报
        public void reportToBoss(String context){
            System.out.println("老板,有情况。。。目标在" + context);
        }
    }
  

• 运行主函数：

    public static void main(String[] args) throws InterruptedException {
        //创建被观察者
        RealObservable Observable = new RealObservable();
        //创建观察者
        ObserverInterface zhangsan = new RealObserver("zhangsan");
        ObserverInterface lisi = new RealObserver("lisi");
        ObserverInterface wangwu = new RealObserver("wangwu");
        //加入观察者集合
        Observable.addObserver(zhangsan);
        Observable.addObserver(lisi);
        Observable.addObserver(wangwu);
        //被观察者发生动作
        Observable.eat();
    }
  

打印结果：</br>
我吃饭了。。。</br>
我是zhangsan观察到对方动作,开始汇报</br>
老板,有情况。。。目标在吃饭了</br>
汇报完毕</br>
我是lisi观察到对方动作,开始汇报</br>
老板,有情况。。。目标在吃饭了</br>
汇报完毕</br>
我是wangwu观察到对方动作,开始汇报</br>
老板,有情况。。。目标在吃饭了</br>
汇报完毕</br>

现在基本上是算完成了，说了这么多，其实JDK中给我们提供了观察者和被观察者(Observer/Observable),当中的方法也和我们所说的差不多，不过看源码可以看出，JDK中的被观察者是使用线程安全的Vector保存观察者对象。

附上使用代码：

• 观察者

  public class RealObserver implements Observer{
  private String name = null;

    public RealObserver(String name){
        this.name = name;
    }
    
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("我是" + name + "观察到对方动作,开始汇报");
        this.reportToBoss(arg.toString());
        System.out.println("汇报完毕");
    }
  
    //获取到情报要汇报
    public void reportToBoss(String context){
        System.out.println("老板,有情况。。。目标在" + context);
    }
  

  }

• 被观察者

    public class RealObservable extends Observable {
        public void eat(){
            System.out.println("我吃饭了");
            super.setChanged();
            super.notifyObservers("吃饭");
        }
        
        public void sleep(){
            System.out.println("我睡觉了");
            super.setChanged();
            this.notifyObservers("睡觉");
        }
    }
  

• 主函数

    public class OberserDemo {
    
        public static void main(String[] args) {
            //创建被观察者
            RealObservable ob = new RealObservable();
            //创建观察者
            Observer zhangsan = new RealObserver("zhangsan");
            Observer lisi = new RealObserver("lisi");
            Observer wangwu = new RealObserver("wangwu");
            //添加进观察者集合
            ob.addObserver(zhangsan);
            ob.addObserver(lisi);
            ob.addObserver(wangwu);
            //被观察者发生动作
            ob.eat();
        }
    }
  

打印结果：</br>
我吃饭了</br>
我是wangwu观察到对方动作,开始汇报</br>
老板,有情况。。。目标在吃饭</br>
汇报完毕</br>
我是lisi观察到对方动作,开始汇报</br>
老板,有情况。。。目标在吃饭</br>
汇报完毕</br>
我是zhangsan观察到对方动作,开始汇报</br>
老板,有情况。。。目标在吃饭</br>
汇报完毕</br>