观察者模式的两种实现和比较

为什么要用观察者模式？

GOF那本书里面是这样描述的：

将一个系统分割成一系列相互协作的类有一个常见的副作用：需要维护相关对象间的一 致性。我们不希望为了维持一致性而使各类紧密耦合，因为这样降低了它们的可重用性。

情景

假设我们有一组数据要用于不同的方案，比如schemeA和schemeB，出于某种原因，A和B之间不能通信，他们不知道彼此的存在。要求当方案改变时可以同时通知到A和B。

BadSolution ：

一个比较不好的解决方法是在数据类里面保持SchemeA和SchemeB的对象来改变数据，Data的代码如下所示：

private SchemeA schemeA;    private SchemeB schemeB;    public void setData(int data1,int data2){        schemeA = new SchemeA();        schemeB = new SchemeB();        schemeA.setData(data1,data2);        schemeB.setData(data1,data2);    }

通过调用setData()来改变数据，这样的做法可以实现但确是一个不好的设计，比如当方案B要被方案C代替了，那么Data类的数据要重写。再者，如果有很多方案的话，这个setData()方法需要将这些方案都写进去。简单来说就是高度耦合，重用性低。这种方案的类顺序图如下所示：

观察者模式来实现

jdk里面实现了观察者模式，这里我们先自己实现这个模式，后文再讲jdk里面的实现。
首先我们定义一个主题Subject：

public interface Subject {     void addObserver(Observer o);     void removeObserver(Observer o);     void notifyAllObservers();}

注意到他有三个方法分别可以注册观察者，移除观察者和通知所有观察者。Data类通过实现这个接口来为SchemeA和SchemeB传送消息。
Data类实现如下：

public class Data implements Subject {    ArrayList observers;    private int data1, data2;    public Data(){        this.observers = new ArrayList();    }    @Override    public void addObserver(Observer observer) {        observers.add(observer);    }    @Override    public void removeObserver(Observer o) {        int i = observers.indexOf(o);        if(i>0) observers.remove(i);    }    @Override    public void notifyAllObservers() {        for (Object obj:observers){            Observer observer = (Observer)obj;            observer.update(data1,data2);        }    }    public void setData(int data1,int data2){        this.data1 = data1;        this.data2 = data2;        measureChange();    }    public void measureChange(){        notifyAllObservers();    }}

而观察者类则可以这样实现：

public interface Observer {    void update(int data1,int data2);}

SchemeA和SchemeB通过实现这个接口的update方法来更新数据。那么Data类怎么知道SchemeA和SchemeB就是观察者呢？一个可行的实现是在构造SchemeA和SchemeB的时候传入Data对象，然后调用Data类的addObserver()方法来为两个方案类注册。
这个系统的类交互图如下所示：

这样设计有什么好处呢？
我们可以看Data类里面的代码，完全没有SchemeA和SchemeB的痕迹，也就是说，无论有多少个方案需要数据，无论方案怎么改变，这个Data类都不需要发生改变，也就可以重用了。而且方案A和方案B之间不知道彼此的存在就能实现数据的同时更新。

用jdk提供的功能来实现

我们的Data类变得简单起来了，因为java.util.Obserable这个类给我们做了很多事情。

public class Data extends Observable {    private int data1,data2;    public Data(){    }    public void setData(int data1,int data2){        this.data1 = data1;        this.data2= data2;        mesureChange();    }    public void mesureChange(){        setChanged();        notifyObservers();    }    public int getData1() {        return data1;    }    public int getData2() {        return data2;    }}

我们只需要像之前实现Subject类那样来继承Observable这个类（不过使用继承的方式会有很多限制，因为java不允许多重继承但可以实现多个接口）。注意measureChange()这个方法，里面调用Observable的两个方法setChange()和notifyObervers()方法。这两个方法的实现都很简单。

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

public void notifyObservers() {        notifyObservers(null);    }

调用有参的notifyObservers()方法。

public void notifyObservers(Object arg) {        Object[] arrLocal;        synchronized (this) {            if (!changed)                return;            arrLocal = obs.toArray();            clearChanged();        }        for (int i = arrLocal.length-1; i>=0; i--)            ((Observer)arrLocal[i]).update(this, arg);    }

这样我们只要使SchemeA和SchemeB方法都实现java.util.Observer接口就可以了。

public class SchemeA implements Observer {    private int data1,data2;    private Observable o;    public SchemeA(Observable o){        o.addObserver(this);    }    @Override    public void update(Observable o, Object arg) {        if(o instanceof Data){            data1 = ((Data) o).getData1();            data2 = ((Data) o).getData2();        }        display();    }    public void display(){        System.out.println("SchemeA display data1 is "+data1+" data2 is "+data2);    }}

使用jdk内置的观察者模式代码简单多了，但是却有时候会有限制，比如Data类已经继承了Observable类，就不能继承其他类了。注意Observable是一个类而不是一个接口。

献上github代码：
https://github.com/cris1313/mingle/tree/master/src/demo/designpatern/observer

完。