最常用的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应用中的实现就在此结束