设计模式（二）观察者模式（Head First）

说起设计模式，那就不得不提一下观察者模式，在android中，观察者模式使用频率还是很高的，比如我们经常用的onclickListener()就是采用的观察者模式实现的。那么观察者模式到底是什么呢，有什么作用，使用它会带来哪些便利？下面就来详细看一下这个伟大的模式。

观察者模式简介

定义

定义了对象之间一对多依赖，这样依赖，当一个对象改变状态时，它的所有依赖者都会受到通知并自动更新。

• Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
• ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
• Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
• ConcrereObserver：具体观察者，是实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

观察者模式代码实现

我们现在将观察者模式应用到WeatherData项目中来。于是有了下面这张类图：

主题接口

/** * Created by yzd on 2017/9/13 0013. * <p> * 主题、被观察者、发布者 */public interface Subject {    /**     * 注册观察者     */    void registerObserver(Observer observer);    /**     * 移除观察者     */    void removeObserver(Observer observer);    /**     * 通知观察者     */    void notifyObservers();}

观察者接口

/** * Created by yzd on 2017/9/13 0013. * 观察者 */public interface Observer {    void update(float temp, float humidity, float pressure);}

公告牌统一接口

/** * Created by yzd on 2017/9/13 0013. */public interface DisplayElement {    /**     * 展示     */    void display();}

具体主题（被观察者、发布者）

/** * Created by yzd on 2017/9/13 0013. */public class WeatherData implements Subject {    private List<Observer> observers;    private float temperature;//温度    private float humidity;//湿度    private float pressure;//气压    public WeatherData() {        observers = new ArrayList<>();    }    @Override    public void registerObserver(Observer observer) {        observers.add(observer);    }    @Override    public void removeObserver(Observer observer) {        int index = observers.indexOf(observer);        if (index >= 0) {            observers.remove(index);        }    }    @Override    public void notifyObservers() {        for (Observer observer : observers) {            observer.update(temperature, humidity, pressure);        }    }    public void measurementsChanged(){        notifyObservers();    }    public void setMeasurements(float temperature, float humidity,                                float pressure) {        this.temperature = temperature;        this.humidity = humidity;        this.pressure = pressure;        measurementsChanged();    }}

显示公告牌1

/** * Created by yzd on 2017/9/13 0013. */public class Display1 implements Observer, DisplayElement {    private Subject weatherData;    private float temperature;//温度    private float humidity;//湿度    private float pressure;//气压    public Display1(Subject weatherData) {        this.weatherData = weatherData;        this.weatherData.registerObserver(this);    }    @Override    public void display() {        Log.e("面板1", "温度:" + temperature + "湿度：" + humidity + "气压" + pressure);    }    @Override    public void update(float temp, float humidity, float pressure) {        this.temperature = temp;        this.humidity = humidity;        this.pressure = pressure;        display();    }}

显示公告牌2

/** * Created by yzd on 2017/9/13 0013. */public class Display2 implements Observer, DisplayElement {    private Subject weatherData;    private float temperature;//温度    private float humidity;//湿度    private float pressure;//气压    public Display2(Subject weatherData) {        this.weatherData = weatherData;        this.weatherData.registerObserver(this);    }    @Override    public void display() {        Log.e("面板2", "温度:" + temperature + "湿度：" + humidity + "气压" + pressure);    }    @Override    public void update(float temp, float humidity, float pressure) {        this.temperature = temp;        this.humidity = humidity;        this.pressure = pressure;        display();    }}

显示公告牌3

/** * Created by yzd on 2017/9/13 0013. */public class Display3 implements Observer, DisplayElement {    private Subject weatherData;    private float temperature;//温度    private float humidity;//湿度    private float pressure;//气压    public Display3(Subject weatherData) {        this.weatherData = weatherData;        this.weatherData.registerObserver(this);    }    @Override    public void display() {        Log.e("面板3", "温度:" + temperature + "湿度：" + humidity + "气压" + pressure);    }    @Override    public void update(float temp, float humidity, float pressure) {        this.temperature = temp;        this.humidity = humidity;        this.pressure = pressure;        display();    }}

测试程序

在android程序中进行测试

 WeatherData weatherData = new WeatherData();        Display1 display1 = new Display1(weatherData);        Display2 display2 = new Display2(weatherData);        Display3 display3 = new Display3(weatherData);        weatherData.setMeasurements(80, 76, 20.9f);        weatherData.setMeasurements(81, 74, 24.9f);        weatherData.setMeasurements(70, 75, 20.5f);        weatherData.setMeasurements(78, 79, 22.1f);

测试结果

E/面板1: 温度:80.0湿度：76.0气压20.9
E/面板2: 温度:80.0湿度：76.0气压20.9
E/面板3: 温度:80.0湿度：76.0气压20.9
E/面板1: 温度:81.0湿度：74.0气压24.9
E/面板2: 温度:81.0湿度：74.0气压24.9
E/面板3: 温度:81.0湿度：74.0气压24.9
E/面板1: 温度:70.0湿度：75.0气压20.5
E/面板2: 温度:70.0湿度：75.0气压20.5
E/面板3: 温度:70.0湿度：75.0气压20.5
E/面板1: 温度:78.0湿度：79.0气压22.1
E/面板2: 温度:78.0湿度：79.0气压22.1
E/面板3: 温度:78.0湿度：79.0气压22.1

当数据发生改变时，这3个面板都会接受到改变后的数据。

优缺点

优点

解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变换都不会影响另一边的变换。

缺点

在应用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。

Android中的观察者模式

android源码中也有很多使用了观察者模式，比如OnClickListener、ContentObserver、android.database.Observable等；还有组件通讯库RxJava、RxAndroid、EventBus；

我们来看看BaseAdaper的部分源码：

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {    //数据集观察者    private final DataSetObservable mDataSetObservable = new DataSetObservable();    public boolean hasStableIds() {        return false;    }    public void registerDataSetObserver(DataSetObserver observer) {        mDataSetObservable.registerObserver(observer);    }    public void unregisterDataSetObserver(DataSetObserver observer) {        mDataSetObservable.unregisterObserver(observer);    }    /**     * 当数据集变化时，通知所有观察者     */    public void notifyDataSetChanged() {        mDataSetObservable.notifyChanged();    }

很明显BaseAdapter用的是观察者模式，BaseAdapter是具体被观察者，接下来看看mDataSetObservable.notifyChanged()：

public class DataSetObservable extends Observable<DataSetObserver> {    public void notifyChanged() {        synchronized(mObservers) {            for (int i = mObservers.size() - 1; i >= 0; i--) {                mObservers.get(i).onChanged();            }        }    }

我们看到了mObservers，这就是观察者的集合，这些观察者是在ListView通过setAdaper()设置Adaper时产生的：

@Override    public void setAdapter(ListAdapter adapter) {        if (mAdapter != null && mDataSetObserver != null) {            mAdapter.unregisterDataSetObserver(mDataSetObserver);        }        ...        super.setAdapter(adapter);        if (mAdapter != null) {            mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();            mOldItemCount = mItemCount;            mItemCount = mAdapter.getCount();            checkFocus();            //创建数据观察者            mDataSetObserver = new AdapterDataSetObserver();            //注册观察者            mAdapter.registerDataSetObserver(mDataSetObserver);            ...        }

接下来看看观察者AdapterDataSetObserver中处理了什么：

class AdapterDataSetObserver extends AdapterView<ListAdapter>.AdapterDataSetObserver {        @Override        public void onChanged() {            super.onChanged();            if (mFastScroller != null) {                mFastScroller.onSectionsChanged();            }        }        @Override        public void onInvalidated() {            super.onInvalidated();            if (mFastScroller != null) {                mFastScroller.onSectionsChanged();            }        }    }

从上面的代码看不出什么，再看看AdapterDataSetObserver的父类AdapterView的AdapterDataSetObserver：

class AdapterDataSetObserver extends DataSetObserver {        private Parcelable mInstanceState = null;        @Override        public void onChanged() {            mDataChanged = true;            mOldItemCount = mItemCount;            mItemCount = getAdapter().getCount();            if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null                    && mOldItemCount == 0 && mItemCount > 0) {                AdapterView.this.onRestoreInstanceState(mInstanceState);                mInstanceState = null;            } else {                rememberSyncState();            }            checkFocus();            //重新布局            requestLayout();        }        ...        public void clearSavedState() {            mInstanceState = null;        }    }

我们看到在onChanged()方法中调用了requestLayout()方法来重新进行布局。好了，看到这里我们都明白了，当ListView的数据发生变化时，我们调用Adapter的notifyDataSetChanged()方法，这个方法又会调用观察者们（AdapterDataSetObserver）的onChanged()方法，onChanged()方法又会调用requestLayout()方法来重新进行布局。

下一篇会对EventBus的源码进行解析。