设计模式——观察者模式

观察者模式——轻松解耦

在曾经的两次面试，被这个模式搞的迷糊，深深的不甘之下，终于忍不住系统的来了解一下这个模式。通常来讲，观察者模式的终极目的是解耦，降低观察者和被观察者之间的依赖，甚至做到毫无依赖，常常用于GUI系统和订阅——发布系统。就拿GUI系统来讲，随着项目的推进，UI模块可能经常性的发生变化，但是业务逻辑模块基本变化不大，如果不将这两个模块有效解耦，就可能造成牵一发而动全身的恶果，此时，就需要一种机制将UI模块和业务逻辑模块进行解耦，这种机制非观察者模式莫属。

定义

观察者模式是定义对象间一种一对多的依赖关系，当一个对象改变状态后，那么所有依赖于它的对象都会收到通知并且自动更新状态。

UML类图表示

• Subject：抽象主题，也就是被观察者角色，该角色将所有观察者对象的引用保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供了增加、删除、通知观察者的接口。

• ConcreteSubject：具体主题，也就是具体的被观察者角色，是抽象主题的实现，该角色将有关状态存入具体观察者对象，当该角色内部的状态改变时，会通知所有注册过的观察者。

• Observer：抽象观察者，是观察者的抽象类，它提供一个接口，使得接到被观察者的通知时及时更新自己。

• ConcreteObserver：具体观察者，是抽象观察者的实现，该角色实现抽象观察者的接口，在接到被观察者的通知时更新自己的状态。

ListView源码中的观察者模式

在Android开发中，ListView是一个非常重要的控件，内部实现也是相当的复杂。在我们向ListView中添加数据并且设置Adapter，当数据集改变后通常会调用Adapter的notifyDataSetChanged()方法来更新数据和界面，这是怎样一个过程，下面我们逐步来剖析。
首先我们来看下notifyDataSetChanged()这个方法，该方法定义在BaseAdapter中

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);
    }

    /**
     * Notifies the attached observers that the underlying data has been changed
     * and any View reflecting the data set should refresh itself.
     * 数据集变化时，通知所有观察者
     */
    public void notifyDataSetChanged() {
        mDataSetObservable.notifyChanged();
    }
    ...
   }

看到BaseAdapter代码，尤其是mDataSetObservable，基本上就能猜到这是一个观察者模式。notifyDataSetChanged内部仅仅是调用DataSetObservable的notifyChanged()方法，再来看看这个方法

public class DataSetObservable extends Observable<DataSetObserver> {
    /**
     * Invokes {@link DataSetObserver#onChanged} on each observer.
     * Called when the contents of the data set have changed.  The recipient
     * will obtain the new contents the next time it queries the data set.
     */
    public void notifyChanged() {
        synchronized(mObservers) {
            // since onChanged() is implemented by the app, it could do anything, including
            // removing itself from {@link mObservers} - and that could cause problems if
            // an iterator is used on the ArrayList {@link mObservers}.
            // to avoid such problems, just march thru the list in the reverse order.
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onChanged();
            }
        }
    }
    ....
}

很简单的逻辑，遍历所有观察者，然后调用观察者的onChanged()方法，我们暂且先不去研究onChanged()方法的实现细节，先来看看这些观察者是从何而来？不过要在此做个标记，后面要返回此处继续分析onChanged()方法。在BaseAdapter代码中我们看到registerDataSetObserver()方法注册了观察者DataSetObserver，那registerDataSetObserver()方法又是在什么地方调用的呢？实际上是在ListView的setAdapter()方法中，现在我们来看看setAdapter()实现

 @Override
    public void setAdapter(ListAdapter adapter) {
        //如果已经有一个adapter，先注销掉该adapter持有的数据观察者
        if (mAdapter != null && mDataSetObserver != null) {
            mAdapter.unregisterDataSetObserver(mDataSetObserver);
        }
        ...

        // AbsListView#setAdapter will update choice mode states.
        super.setAdapter(adapter);

        if (mAdapter != null) {
            mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
            mOldItemCount = mItemCount;
            mItemCount = mAdapter.getCount();
            checkFocus();

            mDataSetObserver = new AdapterDataSetObserver();
            //调用adapter方法注册观察者
            mAdapter.registerDataSetObserver(mDataSetObserver);

            mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());
            ...
        } else {
            mAreAllItemsSelectable = true;
            checkFocus();
            // Nothing selected
            checkSelectionChanged();
        }

        requestLayout();
    }

从代码中可以看到，设置adapter时会创建一个AdapterDataSetObserver并将其注册到adapter中，这就是上面所说的观察者，AdapterDataSetObserver是ListView的父类AdapterView中的内部类，也是DataSetObserver的子类，现在来看看其实现细节

class AdapterDataSetObserver extends DataSetObserver {

        private Parcelable mInstanceState = null;

        @Override
        public void onChanged() {
            mDataChanged = true;
            mOldItemCount = mItemCount;
            //获取adapter中数据的数量
            mItemCount = getAdapter().getCount();

            // Detect the case where a cursor that was previously invalidated has
            // been repopulated with new data.
            if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null
                    && mOldItemCount == 0 && mItemCount > 0) {
                AdapterView.this.onRestoreInstanceState(mInstanceState);
                mInstanceState = null;
            } else {
                rememberSyncState();
            }
            checkFocus();
            //重新布局ListView，重新绘制
            requestLayout();
        }
        ...
    }

最重要的就是onChanged()方法。到目前为止，已经理清楚了观察者和被观察者，现在该回到上面我们标记的地方继续去分析观察者的onChanged()方法了，也就是此处的AdapterDataSetObserver#onChanged()，在该方法中，会调用requestLayout()重新布局ListView，刷新界面。这就是一个观察者模式！
最后，我们再整理一下整个过程，AdapterView中有一个内部类AdapterDataSetObserver，在ListView设置adapter时会构建一个AdapterDataSetObserver，并且注册到adapter中，这是一个观察者。而在Adapter中有一个被观察者DataSetObservable，当数据集发生变更时，开发者调用Adapter.notifyDataSetChanged()，事件传递到DataSetObservable.notifyChanged()，该函数遍历所有观察者的onChanged()方法，在AdapterDataSetObserver.onChanged()中会调用ListView的requestLayout()来更新界面。这就是ListView源码中观察者模式的完整体现。