观察者模式

认识观察者模式

《Head First 设计模式》非常通俗易懂，生动活泼的向我们展示了，各种设计模式，同样观察者模式，也使用《Head First 设计模式》中的小栗子，来解释什么是观察者模式。

先看一下报社和订户的栗子：

1. 报社的业务就是出版报纸。

2. 向某家报社订阅报纸，只要他们有新报纸出版，就会给你送来。只要你是他们的订户，你就会一直收到新报纸。

3. 当你不想再看报纸的时候，取消订阅，他们就不会再送新报纸来。

4. 只要报社还在运营，就会一直有人（或单位）向他们订阅报纸或取消订阅报纸。

出版者 + 订阅者 = 观察者模式

我们把名称改一下，报社即出版者改为主题Subject，订户即订阅者改为观察者Observer，

那如何定义观察者模式呢？当然你也可以使用报社的例子来比对适合观察者模式的场景。

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。观察者模式属于行为型模式。

类图：

• Subject(interface)：这是主题接口，对象使用此接口注册为观察者，或者把自己从观察者中删除。
• ConcreteSubject(class):一个具体主题总是实现主题接口，除了注册和撤销方法之外，具体主题还实现了notifyObservers()方法，此方法用于在状态改变时更新所有当前观察者。
• Observer(interface)：所有潜在的观察者必须实现观察者接口，这个接口只有update()一个方法， 当主题状态改变时它被调用。
• ConcreteObserver(class):具体的观察者可以是实现Observer接口的任意类。观察者必须注册具体主题，以便接收更新。

观察者模式的好处(松耦合)

当两个对象之间松耦合，它们依然可以交互，但是不太清楚彼此的细节。

观察者模式提供了一种对象设计，让主题和观察者之间松耦合。

为什么呢？

关于观察者的一切，主题只知道观察者实现了某个接口，也就是Observer接口。主
题不需要知道观察者的具体类是谁、做了些什么或其他任何细节。任何时候我们都可增加新的观察者。因为主题唯一依赖的东西是一个实现Observer接口的对象列表，所以我们可以随时增加观察者。

事实上，在运行时我们可以用新的观察者取代现有的观察者，主题不会受到任何影响。同样的，也可以在任何时候删除某些观察者。有新类型的观察者出现时，主题的代码不需要修改。假如我们有个新的具体类需要当观察者，我们不需要为了兼容新类型而修改主题的代码，所有要做的就是在新的类里实现此观察者接口，然后注册为观察者即可。主题不在乎别的，它只会发送通知给所有实现了观察者接口的对象。我们可以独立地复用主题或观察者。如果我们在其他地方需要使用主题或观察者，可以轻易地复用，因为二者并非紧耦合。

改变主题或观察者其中一方，并不会影响另一方。因为两者是松耦合的，所以只要他
们之间的接口仍被遵守，我们就可以自由地改变他们。

设计原则

为了交互对象之间的松耦合设计而努力。

松耦合的设计之所以能让我们建立有弹性的OO系统，能够应对变化，
是因为对象之间的互相依赖降到了最低。

针对接口编程，不针对实现。

多用组合少用继承

具体实现

接下来要实现一个，生活中的观察者模式。

当然观察者可能只有一个，也可能只有一个。

比如说你第一次去你的女朋友家里去，七大姑八大姨就是观察者Observer，你就是被观察者也就是Subject。这里只以父母举个栗子。

类结构：

Subject 被观察者主题接口

//被观察者主题接口
public interface Subject {
    //注册成为观察者
    void registObserver(Observer o);
    //反注册移除观察者
    void unRegistObserver(Observer o);
    //通知所有观察者变化
    void notifyAllObservers();
}

Observer 观察者接口

//观察者接口
public interface Observer {
    void update(int score);//接收分数
}

Evaluate 评价接口

//评价接口
public interface Evaluate {
    void evaluate(int score);//根据接受的分数对你进行评价
}

You (主题)被观察者的实现类

//(主题)被观察者的实现类
public class You implements Subject {

    private ArrayList<Observer> observers;
    private int score;

    You() {
        observers = new ArrayList<Observer>();
    }

    public void registObserver(Observer o) {
        if (o != null) {
            observers.add(o);
        }
    }

    public void unRegistObserver(Observer o) {
        int i = observers.indexOf(o);
        if (i >= 0) {
            observers.remove(i);
        }
    }

    public void yourBehavior(int whatBehaviorScore) {
        this.score = whatBehaviorScore;
        notifyAllObservers();
    }

    public void notifyAllObservers() {
        for (Observer o : observers) {
            o.update(score);
        }
    }
}

YourGirlFriendFather观察者的实现类 你女朋友的爸爸

//观察者的实现类 你女朋友的爸爸
public class YourGirlFriendFather implements Observer ,Evaluate{

    private Subject you;
    private int score;

    YourGirlFriendFather(Subject you) {
        this.you = you;
        you.registObserver(this);
    }

    public void update(int score) {
        this.score = score;
        evaluate(score);
    }

    public void evaluate(int score) {
      int fatherScore = score + 20;
        switch (fatherScore) {
            case 20:
                System.out.println("father:还不错有待考察");
                break;
            case 80:
                System.out.println("father:问问他家长啥时候见个面，这小伙子不错");
                break;
            case 100:
                System.out.println("father:跟他家长要个号码，直接订婚");
                break;
            case 120:
                System.out.println("father:你俩先去，领结婚证");
                break;
        }
    }
}

YourGirlFriendMother 观察者的实现类 你女朋友的妈妈

//观察者的实现类 你女朋友的妈妈
public class YourGirlFriendMother implements Observer,Evaluate {

    private Subject you;
    private int score;

    YourGirlFriendMother(Subject you) {
        this.you = you;
        you.registObserver(this);
    }

    public void update(int score) {
        this.score = score;
        evaluate(score);
    }

    public void evaluate(int score) {
        int motherScore = score + 25;
        switch (motherScore) {
            case 25:
                System.out.println("mother:还行，比较傻，说话还不甜");
                break;
            case 85:
                System.out.println("mother:挺温柔，对你很不错，会说话");
                break;
            case 105:
                System.out.println("mother:居家好男人，挣钱多，又高又帅");
                break;
            case 125:
                System.out.println("mother:有房有车，有挣钱，脾气又好，又高又帅，说话甜");
                break;
        }
    }
}

TestObserver 你女朋友的父母观察你的言行举止对你进行评价(观察者模式测试)

//观察者模式测试
public class TestObserver {
    public static void main(String[] args) {
        You you = new You();

        YourGirlFriendFather father = new YourGirlFriendFather(you);
        YourGirlFriendMother mother = new YourGirlFriendMother(you);

        you.yourBehavior(0);
        you.yourBehavior(60);
        you.yourBehavior(80);
        you.yourBehavior(100);
    }
}

运行打印：

father:还不错有待考察
mother:还行，比较傻，说话还不甜
father:问问他家长啥时候见个面，这小伙子不错
mother:挺温柔，对你很不错，会说话
father:跟他家长要个号码，直接订婚
mother:居家好男人，挣钱多，又高又帅
father:你俩先去，领结婚证
mother:有房有车，有挣钱，脾气又好，又高又帅，说话甜

观察者模式在实际应用中的缺点和优点总结

优点

• 观察者和被观察者之间是抽象耦合，应对业务变化能力强，可扩展性强；
• 观察者模式支持广播通讯。被观察者会向所有的登记过的观察者发出通知。

同时观察者模式也有一些缺点

• 观察者模式有时会有开发效率和运行效率的问题，程序中包括一个被观察者和多个观察者时，调试和开发会相对变得复杂；
• 观察者如果数量很多，所有的观察者都通知到会花费一定时间；
• 观察者模式中被观察者通知观察者时默认是顺序执行，所以当一个观察者执行缓慢或者卡顿就会影响整体的执行效率，如果有这种情况最好采用异步执行的方式去处理；
• 如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃，在使用观察者模式时要特别注意这一点。

参考

《Head First 设计模式》

23种设计模式（8）：观察者模式

java/android 设计模式学习笔记目录

观察者模式（ObserverPattern）