android 设计模式—— 观察者模式

整理：

观察者模式，是一种非常常见的设计模式，在很多系统中随处可见，尤其是涉及到数据状态发生变化需要通知的情况下。
本文以AbstractCursor为例子，展开分析。
观察者模式，Observer Pattern,是一个很实用的模式，本人曾经接触到的各种平台以及曾经参与项目中打印模板解释器中都用到了此模式。

1.意图
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
热门词汇：依赖 发布-订阅 事件 通知 更新 监听 

2.结构

这是一个最简单的观察者模式，目标对象能够添加和删除观察者，当自己某种状态或者行为发生改变时，可通过notify通知注册的观察者进行更新操作。
分析AbstractCursor的具体情况，我们发现实际工作有时需要对观察者进行统一管理，甚至观察者类型有很多种而又可以分成几个系列，这个时候是要复杂的多，通过合理的分层这个问题很好解决。下面根据具体情况，我们画出android中abstractCurosr中用到的观察者模式结构图：

观察者分成了两个系列。

3.代码
列举其中相关核心代码如下：

public  abstract  class  AbstractCursor {
    //定义管理器
    DataSetObservable mDataSetObservable = new  DataSetObservable();
    ContentObservable mContentObservable = new  ContentObservable();

    //注册和卸载两类观察者
    public  void  registerContentObserver(ContentObserver observer) {
        mContentObservable.registerObserver(observer);
    }

    public  void  unregisterContentObserver(ContentObserver observer) {
        // cursor will unregister all observers when it close
        if  (!mClosed) {
            mContentObservable.unregisterObserver(observer);
        }
    }

    public  void  registerDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.registerObserver(observer);

    }

    public  void  unregisterDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.unregisterObserver(observer);
    }

    //2类通知方法
    protected  void  onChange( boolean  selfChange) {
        synchronized  (mSelfObserverLock) {
            mContentObservable.dispatchChange(selfChange);
            if  (mNotifyUri != null  && selfChange) {
                mContentResolver.notifyChange(mNotifyUri, mSelfObserver);
            }
        }
    }

    protected  void  notifyDataSetChange() {
        mDataSetObservable.notifyChanged();
    }
}

　　再看看Observable<T>类和DataSetObservable类:

public  abstract  class  Observable<T> {
    /**
     * 观察者列表
     */
    protected  final  ArrayList<T> mObservers = new  ArrayList<T>();

    public  void  registerObserver(T observer) {
        if  (observer == null ) {
            throw  new  IllegalArgumentException( "The observer is null." );
        }
        synchronized (mObservers) {
            if  (mObservers.contains(observer)) {
                throw  new  IllegalStateException( "Observer "  + observer + " is already registered." );
            }
            mObservers.add(observer);
        }
    }


    public  void  unregisterObserver(T observer) {
        if  (observer == null ) {
            throw  new  IllegalArgumentException( "The observer is null." );
        }
        synchronized (mObservers) {
            int  index = mObservers.indexOf(observer);
            if  (index == - 1 ) {
                throw  new  IllegalStateException( "Observer "  + observer + " was not registered." );
            }
            mObservers.remove(index);
        }
    }

    public  void  unregisterAll() {
        synchronized (mObservers) {
            mObservers.clear();
        }
    }
}

　　和

public  class  DataSetObservable extends  Observable<DataSetObserver> {
    /**
     * 数据发生变化时，通知所有的观察者
     */
    public  void  notifyChanged() {
        synchronized (mObservers) {
            for  (DataSetObserver observer : mObservers) {
                observer.onChanged();
            }
        }
    }
    //... ... (其他方法)
}

　　观察者DataSetObserver类是一个抽象类：

public  abstract  class  DataSetObserver {
    public  void  onChanged() {
        // Do nothing
    }
}

　　所以我们具体看它的子类：

public  class  AlphabetIndexer extends  DataSetObserver{
    /*
     * @hide 被android系统隐藏起来了
     */
    @Override
    public  void  onChanged() {
        //观察到数据变化，观察者做自己该做的事情
        super .onChanged();
        mAlphaMap.clear();
    }
}

　　ContentObserver也是类似。

4.效果
(1).行为型模式
(2).目标和观察者间的抽象耦合(经典实现)。
(3).支持广播通信(相信这点android开发者看到后应该有启发吧)。
(4).注意意外的更新，这也是观察者更新进行管理的原因之一。