观察者（Observer）模式

观察者（Observer）模式

1、啥是观察者模式

观察者模式，顾名思义就是他将会观察一个对象，那个对象就是被观察者，当被观察者中观察者感兴趣的状态或者行为发生变动时，观察者就会马上接到通知。说到这里突然想到一个绝妙的例子来说明这个现象。在公司里大家都是看老板脸色吃饭，老板去上厕所了，老板回家了，老板在打电话了，这些信息我们都想知道，这样我们就可以偷个懒，打把农药，刷个朋友圈，在这里一个很重要的点就是我们需要及时知道老板在干吗，好啦这时候我们就需要观察者模式了，老板就是我们的被观察者。
观察者模式的类图如下

2、举个栗子？？？

我们已经知道观察者模式的基本概念以及类图，这里选择公司上班的例子demo，让观察者模式呈现的更加立体。
首先需要一个观察者与被观察者的接口

public interface Observer {
    String update(String stirng);
}

public interface Observable {
    void registObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyAllObserver();
}

接着老板观察者作为安插在老板旁边的内线作为被观察者，需要继承Observable接口

public class BossObserver implements Observable{
    List<Observer> observerList = new ArrayList<>();
    @Override
    public void registObserver(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observerList.remove(observer);
    }

    @Override
    public void notifyAllObserver() {
        for (Observer observer:observerList) {
            observer.update("上厕所去了");
        }
    }
}

员工们作为观察者，要时刻留意老板观察者传回来的信息。

public class XiaoLi implements Observer{
    @Override
    public String update(String string) {
        System.out.println("小李，老板"+string);
        return string;
    }
}

public class XiaoMing implements Observer{
    @Override
    public String update(String string) {
        System.out.println("小明，老板"+string);

        return string;
    }
} 

public class XiaoZhang implements Observer{
    @Override
    public String update(String string) {
        System.out.println("小张，老板"+string);
        return string;
    }
}

在这里三个员工作为观察者时刻关注老板动向

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        button = (Button) findViewById(R.id.button);
        button.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        Observable boss = new Boss();
        Observer xiaoming = new XiaoMing();
        Observer xiaoli = new XiaoLi();
        Observer xiaozhang = new XiaoZhang();
        boss.registObserver(xiaoming);
        boss.registObserver(xiaoli);
        boss.registObserver(xiaozhang);
        boss.notifyAllObserver();
    }
}

老板刚上厕所，员工就已经收到消息了。如图所示：

通过这个例子，应当对观察者模式有了一个直观的感受。其实jdk中已经替我们实现过观察者。

3、jdk中的观察者

public interface Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param   o     the observable object.
     * @param   arg   an argument passed to the <code>notifyObservers</code>
     *                 method.
     */
    void update(Observable o, Object arg);
}

public class Observable {
    private boolean changed = false;
    private final ArrayList<Observer> observers;

    /** Construct an Observable with zero Observers. */

    public Observable() {
        observers = new ArrayList<>();
    }

    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!observers.contains(o)) {
            observers.add(o);
        }
    }

    public synchronized void deleteObserver(Observer o) {
        observers.remove(o);
    }
    public void notifyObservers() {
        notifyObservers(null);
    }


    public void notifyObservers(Object arg) {

        Observer[] arrLocal;

        synchronized (this) {

            if (!hasChanged())
                return;

            arrLocal = observers.toArray(new Observer[observers.size()]);
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            arrLocal[i].update(this, arg);
    }


    public synchronized void deleteObservers() {
        observers.clear();
    }

    protected synchronized void setChanged() {
        changed = true;
    }

    protected synchronized void clearChanged() {
        changed = false;
    }
    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return observers.size();
    }
}

仔细看看这两个类，其实和我们写的挺类似的，可是原生的观察者我们最起码能看到两个缺点
1、首先，他的observable是一个类，且并没有提供接口，你必须设计一个类继承它。如果某类相同时具有observable类和另外一个超类的行为就会陷入两难。
2、在原生的observable中有个很关键的方法setChanged()方法，必须先调用它观察者模式才能起效果。但是这个方法被保护protected起来了,除非你继承自observable，否则你无法创建observable实例并组合到自己的对象中。违反了“多用组合，少用继承”的原则。

4、实际中的应用

在前几天开发android项目的过程中，有这么一个需求，需要从网络读取数据到本地显示，大家知道网络请求属于耗时操作，我们必须在子线程中去实现，可是项目必须在打开的时候马上显示数据，且数据请求在子线程中，我们无法准确知道什么时候能读取到数据，这时候观察者模式就起作用了。我们可以，创建一个接口listener，在网络请求成功并获取到数据后调用此接口listener，将数据传入接口中，然后给activity调用，在读取成功的接口里进行数据展示的操作。在这里每一个需要数据且注册了接口的就是观察者，发送数据接口的就是被观察者，一旦获取数据成功，就可以通知各个观察者通过接口接收数据了。