最常用的Java設計之一 觀察者模式 在android中的實例 ListView Adapter機制

我們都知道ListView都必須有設置適配器的這個步驟，即setAdapter(ListAdapter adapter),而在這裏andriod framework使用到了Java觀察者模式。
在你看下面的解析之前，讀者必須要先對觀察者模式有一定了解，因爲下面的解析都是觀察者的應用實例，沒有對觀察者的概念和簡單實例進行講解
 
 mAdapter = adapter;
 mDataSetObserver = new AdapterDataSetObserver();
 mAdapter.registerDataSetObserver(mDataSetObserver);
這是ListView 的setAdapter裏面的了兩句代碼,看名字就知道跟觀察者有關係。繼續看下面源代碼
class AdapterDataSetObserver extends AdapterView<ListAdapter>.AdapterDataSetObserver {
        @Override
        public void onChanged() {
            super.onChanged();
            if (mFastScroller != null) {
                mFastScroller.onSectionsChanged();
            }
        }
       
    }
這是ListView的直接父類AbsListView裏面的一個類，繼續看AdapterView裏面的源代碼
class AdapterDataSetObserver extends DataSetObserver {




        private Parcelable mInstanceState = null;




        @Override
        public void onChanged() {
            mDataChanged = true;
            mOldItemCount = mItemCount;
            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();
            requestLayout();
        }
}


下面看DataSetObserver源代碼
public abstract class DataSetObserver {
    /**
     * This method is called when the entire data set has changed,
     * most likely through a call to {@link Cursor#requery()} on a {@link Cursor}.
     */
    public void onChanged() {
        // Do nothing
    }
}






到這裏觀察者模式的觀察者開始出現了，DataSetObserver其實就是觀察者，通過setAdapter就可以執行到mAdapter.registerDataSetObserver(mDataSetObserver)。
接着看mAdapter,
mAdapter在ListView的父類AbsListView中定義,
 /**
     * The adapter containing the data to be displayed by this view
     */
ListAdapter mAdapter;


ListAdapter是一個接口，其直接父類爲Adapter，Adapter裏面部分源代碼如下
 
 /**
     * Register an observer that is called when changes happen to the data used by this adapter.
     *
     * @param observer the object that gets notified when the data set changes.
     */
void registerDataSetObserver(DataSetObserver observer);
到這裏觀察者模式的通知者信息也知道了，ListView每次setAdapter後都會mAdapter.registerDataSetObserver但是registerDataSetObserver這個方法做了啥呢？看下面
我們setAdapter後會把我們實現的BaseAdapter傳進來也就是mAdapter,在BaseAdapter中源代碼如下
 private final DataSetObservable mDataSetObservable = new DataSetObservable();


    public boolean hasStableIds() {
        return false;
    }
    
    public void registerDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.registerObserver(observer);
    }


接着看下面
DataSetObservable 的直接父類如下
public abstract class Observable<T> {
    /**
     * The list of observers.  An observer can be in the list at most
     * once and will never be null.
     */
    protected final ArrayList<T> mObservers = new ArrayList<T>();


    /**
     * Adds an observer to the list. The observer cannot be null and it must not already
     * be registered.
     * @param observer the observer to register
     * @throws IllegalArgumentException the observer is null
     * @throws IllegalStateException the observer is already registered
     */
    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);
        }
    }
}


DataSetObservable其實就是就通知者，裏面實現方法有增加觀察者和通知觀察者等


既然是觀察者模式那麼在什麼時候通知者開始通知觀察者呢？請看下面


ListView中的AddHeaderView和removeHeaderView的時候會通知一次觀察者，addFooterView和removeFooterView也同樣會通知
public void addHeaderView(View v, Object data, boolean isSelectable) {


        if (mAdapter != null && ! (mAdapter instanceof HeaderViewListAdapter)) {
            throw new IllegalStateException(
                    "Cannot add header view to list -- setAdapter has already been called.");
        }


        FixedViewInfo info = new FixedViewInfo();
        info.view = v;
        info.data = data;
        info.isSelectable = isSelectable;
        mHeaderViewInfos.add(info);


        // in the case of re-adding a header view, or adding one later on,
        // we need to notify the observer
        if (mAdapter != null && mDataSetObserver != null) {
            mDataSetObserver.onChanged();
        }
    }


public boolean removeHeaderView(View v) {
        if (mHeaderViewInfos.size() > 0) {
            boolean result = false;
            if (mAdapter != null && ((HeaderViewListAdapter) mAdapter).removeHeader(v)) {
                if (mDataSetObserver != null) {
                    mDataSetObserver.onChanged();
                }
                result = true;
            }
            removeFixedViewInfo(v, mHeaderViewInfos);
            return result;
        }
        return false;
    }


我們都知道在使用ListView時都會使用到notifyDataSetChanged()這個方法，那個這個方法做什麼事呢？請下面
notifyDataSetChanged()值BaseAdapter裏面的方法
/**
     * 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();
    }
調用這個方法後通知者mDataSetObservable執行notifyChanged()操作,
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();
            }
        }
    }
顯然這個方法面同樣通知了觀察者。而ListView每次的通知都會刷新一次ListView。
到此觀察者模式在android應用中的實現就在此結束