设计模式---观察者模式

来源：互联网发布：c语言缺陷与陷阱编辑：程序博客网时间：2024/06/06 14:16

定义：

对象间的一对多关系，当一个对象发生改变时，所依赖它的对象都会得到通知

（当某个事件发生，会引发其它事件的发送）

现实生活中场景：

1.电饭锅煮饭，当室内饭熟了，会自动跳转到保温模式

2.ATM取款机，输入密码连续几次错误时，自动吞卡，并通知摄像头连续拍摄

类图：

通用代码：

观察者：

package com.lt.observer;public interface Observer {public void update();}

被观察者：

package com.lt.observer;import java.util.ArrayList;import java.util.List;public abstract class Subject {public List<Observer> list = new ArrayList<Observer>();public void addObserver(Observer observer) {list.add(observer);}public void deleteObserver(Observer observer) {list.remove(observer);}public void notifyObservers() {for (Observer observer : list) {observer.update();}}}

观察者A：

package com.lt.observer;public class ObserverA implements Observer{@Overridepublic void update() {System.out.println("观察者A:update");}}

观察者B:

package com.lt.observer;public class ObserverB implements Observer{@Overridepublic void update() {System.out.println("观察者B:update");}}

main方法：

package com.lt.observer;public class Main {public static void main(String[] args) {SubjectA subjectA = new SubjectA();ObserverA observerA = new ObserverA();ObserverB observerB = new ObserverB();subjectA.addObserver(observerA);subjectA.addObserver(observerB);subjectA.notifyObservers();}}

结果：

java中提供了已经封装好的Observer和Observable类。

Android中观察者模式的应用：

BaseAdapter对象调用notifyDataSetChanged()方法通知ListView对象刷新界面，BaseAdapter相当于“被观察者”，ListView相当于“观察者”，当BaseAdapter对象的数据发生变化时，调用notifyDataSetChanged()通知ListView对象刷新界面。

原代码：

/**     * 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调用notifyDataSetChanged()，在该方法中调用mDataSetObservable的notifyChanged()，接下来我们看看mDataSetObservable和notifyChanged()方法

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {    private final DataSetObservable mDataSetObservable = new DataSetObservable();

mDataSetObservable为DataSetObservable的实例，从这边我们可以知道mDataSetObservable就是观察者模式中的被观察者对象，DataSetObservable为被观察者类

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

notifyChanged()方法中循环通知所有的观察者，调用观察者的onChanged()方法，该方法我们在第8步中再看，mObservers为观察者对象队列，那么mObservers从哪里来的呢，可以推断出在父
类Observable<DataSetObserver>中声明，我们再看Observable<DataSetObserver>类

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

mObservers是存放观察者的ArrayList，该类中用registerObserver(T observer)方法来注册一个观察者，这个方法哪里被调用的呢，来注册观察者呢。

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

在BaseAdapter类中我们可以看到registerDataSetObserver(DataSetObserver observer)方法调用了在第4步中的registerObserver(T observer)的方法，这个方法有在哪里调用的呢

 @Override    public void setAdapter(ListAdapter adapter) {        if (mAdapter != null && mDataSetObserver != null) {            mAdapter.unregisterDataSetObserver(mDataSetObserver);        }        resetList();        mRecycler.clear();        if (mHeaderViewInfos.size() > 0|| mFooterViewInfos.size() > 0) {            mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, adapter);        } else {            mAdapter = adapter;        }        mOldSelectedPosition = INVALID_POSITION;        mOldSelectedRowId = INVALID_ROW_ID;        // 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();            mAdapter.registerDataSetObserver(mDataSetObserver);            mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());

在ListView类中setAdapter方法中可以看调用了mAdapter.registerDataSetObserver(mDataSetObserver)这个方法，在这里我们终于看到了第四步中mObservers的成员是从这里注册的，观察者对象为mDateSetObserver,接下来我们再看看mDateSetObserver对象。

/**     * Should be used by subclasses to listen to changes in the dataset     */    AdapterDataSetObserver mDataSetObserver;

mDateSetObserver对象是AdapterDataSetObserver类的实例

现在我们再来看看第三步中的提到的onChanged方法，这个方法重写了父类的onChanged方法，我们再看看其父类的onChangede方法

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

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

该方法中最终zui调用了requestLayout()方法来重新刷新界面，也就是刷新了ListView。

总结：

ListView对象调用setAdapter(ListAdapter adapter)方法，

在该方法中调用adapter.registerDataSetObserver(mDataSetObserver),

registerDataSetObserver(mDataSetObserver)方法中又调用 mDataSetObservable.registerObserver(observer)方法，

完成”被观察者”mDataSetObservable注册”观察者”mDataSetObserver；

当adapter数据发生改变时，调用notifyDataSetChanged（）方法，

在该方法中又调用mDataSetObservable的notifyChanged()方法来通知观察者，

观察者调用onChanged()方法，执行requestLayout()来刷新界面

事件响应：

button.setonclickListener();

广播接受：

0 0