设计模式15---Android 观察者模式（转载自：“http://blog.csdn.net/fangchongbory/article/details/7774044”）

2023-01-12 23:13:44

  1. /*
  2. * 观察者模式
  3. *      定义对象间的一种一个(Subject)对多(Observer)的依赖关系，当一个对象的状态发送改变时，所以依赖于它的
  4. * 对象都得到通知并被自动更新
  5. *
  6. * 当然，MVC只是Observer模式的一个实例。Observer模式要解决的问题为：
  7. * 建立一个一（Subject）对多（Observer）的依赖关系，并且做到当“一”变化的时候，
  8. * 依赖这个“一”的多也能够同步改变。最常见的一个例子就是：对同一组数据进行统计分析时候，
  9. * 我们希望能够提供多种形式的表示（例如以表格进行统计显示、柱状图统计显示、百分比统计显示等）。
  10. * 这些表示都依赖于同一组数据，我们当然需要当数据改变的时候，所有的统计的显示都能够同时改变。
  11. * Observer模式就是解决了这一个问题。
  12. *
  13. * 适用性：
  14. *      1. 当一个抽象模型有两个方面，其中一个方面依赖于另一方面
  15. *      将这两者封装成独立的对象中以使它们可以各自独立的改变和服用
  16. *
  17. *      2. 当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变
  18. *
  19. *      3. 当一个对象必须通知其它对象，而它又不能假定其它对象是谁
  20. *
  21. * 参与者：
  22. *      1. Subject（目标）
  23. *      目标知道它的观察者，可以有任意多个观察者观察同一个目标
  24. *      提供注册和删除观察者对象的接口
  25. *
  26. *      2. Observer（观察者）
  27. *      为那些在目标发生改变时需获得通知的对象定义个更新的接口
  28. *
  29. *      3. ConcreteSubject（具体目标）
  30. *      将有关状态存入各ConcreteObserver对象
  31. *      当它的状态发送改变时，向它的各个观察者发出通知
  32. *
  33. *      4. ConcreteObserver（具体观察者）
  34. *      维护一个指向ConcreteObserver对象的引用
  35. *      存储有关状态，这些状态应与目标的状态保持一致
  36. *      实现Observer的更新接口是自身状态与目标的状态保持一致
  37. *
  38. *
  39. * */

有空我将把UML图补上。

下面看看Android使用到的观察者模式.

观察者（DataSetObserver），目标（Observable<T>），具体目标（DataSetObserverable）

Observer(观察者)，DataSetObserver抽象2个方法，一个是观察数据改变的方法，一个是观察数据变成无效（或者不可用）时的方法。

源码路径：framework/base/core/java/android/database/DataSetObserver.java

  1. package android.database;
  2. /**
  3. * Receives call backs when a data set has been changed, or made invalid. The typically data sets
  4. * that are observed are {@link Cursor}s or {@link android.widget.Adapter}s.
  5. * DataSetObserver must be implemented by objects which are added to a DataSetObservable.
  6. */
  7. public abstract class DataSetObserver {
  8. /**
  9. * This method is called when the entire data set has changed,
  10. * most likely through a call to {@link Cursor#requery()} on a {@link Cursor}.
  11. */
  12. public void onChanged() {
  13. // Do nothing
  14. }
  15. /**
  16. * This method is called when the entire data becomes invalid,
  17. * most likely through a call to {@link Cursor#deactivate()} or {@link Cursor#close()} on a
  18. * {@link Cursor}.
  19. */
  20. public void onInvalidated() {
  21. // Do nothing
  22. }
  23. }

Subject(目标)，Observable<T>是一个泛型的抽象类，主要功能是注册和撤销observer。

源码路径：framework/base/core/java/android/database/Observable.java

  1. package android.database;
  2. import java.util.ArrayList;
  3. /**
  4. * Provides methods for (un)registering arbitrary observers in an ArrayList.
  5. */
  6. public abstract class Observable<T> {
  7. /**
  8. * The list of observers.  An observer can be in the list at most
  9. * once and will never be null.
  10. */
  11. protected final ArrayList<T> mObservers = new ArrayList<T>();
  12. /**
  13. * Adds an observer to the list. The observer cannot be null and it must not already
  14. * be registered.
  15. * @param observer the observer to register
  16. * @throws IllegalArgumentException the observer is null
  17. * @throws IllegalStateException the observer is already registered
  18. */
  19. public void registerObserver(T observer) {
  20. if (observer == null) {
  21. throw new IllegalArgumentException("The observer is null.");
  22. }
  23. synchronized(mObservers) {
  24. if (mObservers.contains(observer)) {
  25. throw new IllegalStateException("Observer " + observer + " is already registered.");
  26. }
  27. mObservers.add(observer);
  28. }
  29. }
  30. /**
  31. * Removes a previously registered observer. The observer must not be null and it
  32. * must already have been registered.
  33. * @param observer the observer to unregister
  34. * @throws IllegalArgumentException the observer is null
  35. * @throws IllegalStateException the observer is not yet registered
  36. */
  37. public void unregisterObserver(T observer) {
  38. if (observer == null) {
  39. throw new IllegalArgumentException("The observer is null.");
  40. }
  41. synchronized(mObservers) {
  42. int index = mObservers.indexOf(observer);
  43. if (index == -1) {
  44. throw new IllegalStateException("Observer " + observer + " was not registered.");
  45. }
  46. mObservers.remove(index);
  47. }
  48. }
  49. /**
  50. * Remove all registered observer
  51. */
  52. public void unregisterAll() {
  53. synchronized(mObservers) {
  54. mObservers.clear();
  55. }
  56. }
  57. }

ConcreateSubject(具体目标)，实现的方法同Oberver一样，只不过它是通知ArrayList<Observer>下的每个Oberver去执行各自的action。

源码路径：framework/base/core/java/android/database/DataSetObservable.java

  1. package android.database;
  2. /**
  3. * A specialization of Observable for DataSetObserver that provides methods for
  4. * invoking the various callback methods of DataSetObserver.
  5. */
  6. public class DataSetObservable extends Observable<DataSetObserver> {
  7. /**
  8. * Invokes onChanged on each observer. Called when the data set being observed has
  9. * changed, and which when read contains the new state of the data.
  10. */
  11. public void notifyChanged() {
  12. synchronized(mObservers) {
  13. // since onChanged() is implemented by the app, it could do anything, including
  14. // removing itself from {@link mObservers} - and that could cause problems if
  15. // an iterator is used on the ArrayList {@link mObservers}.
  16. // to avoid such problems, just march thru the list in the reverse order.
  17. for (int i = mObservers.size() - 1; i >= 0; i--) {
  18. mObservers.get(i).onChanged();
  19. }
  20. }
  21. }
  22. /**
  23. * Invokes onInvalidated on each observer. Called when the data set being monitored
  24. * has changed such that it is no longer valid.
  25. */
  26. public void notifyInvalidated() {
  27. synchronized (mObservers) {
  28. for (int i = mObservers.size() - 1; i >= 0; i--) {
  29. mObservers.get(i).onInvalidated();
  30. }
  31. }
  32. }
  33. }

ConcreateObserver(具体观察者),具体观察者的任务是实实在在执行action的类，一般由开发者根据实际情况，自己实现。android也有实现的例子

源码路径：

framework/base/core/java/android/widget/AbsListView.java

  1. class AdapterDataSetObserver extends AdapterView<ListAdapter>.AdapterDataSetObserver {
  2. @Override
  3. public void onChanged() {
  4. super.onChanged();
  5. if (mFastScroller != null) {
  6. mFastScroller.onSectionsChanged();
  7. }
  8. }
  9. @Override
  10. public void onInvalidated() {
  11. super.onInvalidated();
  12. if (mFastScroller != null) {
  13. mFastScroller.onSectionsChanged();
  14. }
  15. }
  16. }

framework/base/core/java/android/widget/AdapterView.java

  1. class AdapterDataSetObserver extends DataSetObserver {
  2. private Parcelable mInstanceState = null;
  3. @Override
  4. public void onChanged() {
  5. mDataChanged = true;
  6. mOldItemCount = mItemCount;
  7. mItemCount = getAdapter().getCount();
  8. if (DBG) {
  9. Xlog.d(TAG, "AdapterView onChanged: mOldItemCount = " + mOldItemCount
  10. + ",mItemCount = " + mItemCount + ",getAdapter() = " + getAdapter()
  11. + ",AdapterView = " + AdapterView.this, new Throwable("onChanged"));
  12. }
  13. // Detect the case where a cursor that was previously invalidated has
  14. // been repopulated with new data.
  15. if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null
  16. && mOldItemCount == 0 && mItemCount > 0) {
  17. AdapterView.this.onRestoreInstanceState(mInstanceState);
  18. mInstanceState = null;
  19. } else {
  20. rememberSyncState();
  21. }
  22. checkFocus();
  23. requestLayout();
  24. }
  25. @Override
  26. public void onInvalidated() {
  27. mDataChanged = true;
  28. if (DBG) {
  29. Xlog.d(TAG, "AdapterView onInvalidated: mOldItemCount = " + mOldItemCount
  30. + ",mItemCount = " + mItemCount + ",getAdapter() = " + getAdapter()
  31. + ",AdapterView = " + AdapterView.this, new Throwable("onInvalidated"));
  32. }
  33. if (AdapterView.this.getAdapter().hasStableIds()) {
  34. // Remember the current state for the case where our hosting activity is being
  35. // stopped and later restarted
  36. mInstanceState = AdapterView.this.onSaveInstanceState();
  37. }
  38. // Data is invalid so we should reset our state
  39. mOldItemCount = mItemCount;
  40. mItemCount = 0;
  41. mSelectedPosition = INVALID_POSITION;
  42. mSelectedRowId = INVALID_ROW_ID;
  43. mNextSelectedPosition = INVALID_POSITION;
  44. mNextSelectedRowId = INVALID_ROW_ID;
  45. mNeedSync = false;
  46. checkFocus();
  47. requestLayout();
  48. }
  49. public void clearSavedState() {
  50. mInstanceState = null;
  51. }
  52. }

实例：

型运用是大家熟悉的BaseAdapter，BaseAdapter关联了一个DataSetObservable对象，并实现registerDataSetObserver和unregisterDataSetObserver两个方法实现注册和撤销Observer，方法notifyDataSetChanged间接调用Observer的实现者的onChange()方法，以达到通知数据改变的作用。使用ListView和BaseAdapter组合时，当BaseAdapter的item改变时，我们经常会调用notifyDataSetChanged()，通知Listview刷新。

但是，但是，但是，我们从来没有调用BaseAdapter的registerDataSetObserver(DataSetObserver observer)注册Observer，那么Listview如何接收到通知，并执行刷新动作呢？

我们来看看ListView做了什么

  1. /**
  2. * Sets the data behind this ListView.
  3. *
  4. * The adapter passed to this method may be wrapped by a {@link WrapperListAdapter},
  5. * depending on the ListView features currently in use. For instance, adding
  6. * headers and/or footers will cause the adapter to be wrapped.
  7. *
  8. * @param adapter The ListAdapter which is responsible for maintaining the
  9. *        data backing this list and for producing a view to represent an
  10. *        item in that data set.
  11. *
  12. * @see #getAdapter()
  13. */
  14. @Override
  15. public void setAdapter(ListAdapter adapter) {
  16. if (mAdapter != null && mDataSetObserver != null) {
  17. mAdapter.unregisterDataSetObserver(mDataSetObserver);
  18. }
  19. resetList();
  20. mRecycler.clear();
  21. if (mHeaderViewInfos.size() > 0|| mFooterViewInfos.size() > 0) {
  22. mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, adapter);
  23. } else {
  24. mAdapter = adapter;
  25. }
  26. mOldSelectedPosition = INVALID_POSITION;
  27. mOldSelectedRowId = INVALID_ROW_ID;
  28. // AbsListView#setAdapter will update choice mode states.
  29. super.setAdapter(adapter);
  30. if (mAdapter != null) {
  31. mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
  32. mOldItemCount = mItemCount;
  33. mItemCount = mAdapter.getCount();
  34. checkFocus();
  35. mDataSetObserver = new AdapterDataSetObserver();
  36. mAdapter.registerDataSetObserver(mDataSetObserver);
  37. mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());
  38. int position;
  39. if (mStackFromBottom) {
  40. position = lookForSelectablePosition(mItemCount - 1, false);
  41. } else {
  42. position = lookForSelectablePosition(0, true);
  43. }
  44. setSelectedPositionInt(position);
  45. setNextSelectedPositionInt(position);
  46. if (mItemCount == 0) {
  47. // Nothing selected
  48. checkSelectionChanged();
  49. }
  50. } else {
  51. mAreAllItemsSelectable = true;
  52. checkFocus();
  53. // Nothing selected
  54. checkSelectionChanged();
  55. }
  56. requestLayout();
  57. }

注意下面3行

  1. mAdapter = adapter;
  1. mDataSetObserver = new AdapterDataSetObserver();
  2. mAdapter.registerDataSetObserver(mDataSetObserver);

当我们setAdapter(ListAdapter adapter)时，BaseAdapter同时注册了AdapterDataSetObserver()，至于AdapterDataSetObserver是如何通知Listvew和每个子item刷新（invalidate）的，这里涉及到的内容已经超出文章的范围，具体请查看源码。

其实，Android用到DataSetObserver的地方很多，Cursor,WebView,Adapter,...非常之多。

上一篇：[镜像]镜像操作losetup


下一篇：阿里云RDS for SQL Server使用的一些最佳实践