生活中我们常认定某些人很有才，但什么是有才呢？明朝的王守仁曾这样解释：才，是所谓天理，应用到物上，便成了才。凡事凡物，只要掌握了所谓科学的方法，并能灵活运用，那么你也可以成为一个有才的人。
观察者模式是软件设计都会运用到的一种模式，无论何种预言，由于本人是android猿类，所以本篇仅探讨android中的观察者模式，为了详致地阐述这一模式，本文分为三个部分：概念、简单实现、android中listview的具体实现。看完这三部分，相信您自己也能够驾轻就熟地在自己的软件中编写观察者模式了。
每逢花晨月夕，便有丝竹管弦之兴，美文就要来袭了：）
一、概念
- 定义 观察者模式是由一个发送者（发送者是笔者自己的称呼，觉较之被观察者贴切得多）和一个观察者构成的、发送者在状态改变时（用户操作、程序主动改变等）主动通知所有观察者作相应的刷新。
- 作用 面向对象的设计原则之一就是特定的对象干特定的事，比如眼睛对象和大脑对象 ，眼睛只需负责看，将看到的信息传给大脑，大脑只负责根据 接收到的信息作出对应的反应。观察者模式提供了良好的解耦。
- 理论实现 观察者模式定义了对象之间一对多的的依赖关系，以便一个对象的状态发生改变时，所有依赖于他的对象都能够得到通知，并自动刷新。ps：这句话是复制的，如果你看得似是而非，请带着疑问看完简单实现部分就明白了。
- 成员介绍 观察者：（Observer）将自己注册到被观察对象（Subject）中，被观察对象将观察者存放在一个容器（Container）里。被观察者：被观察对象发生了某种变化，从容器中得到所有注册过的观察者，将变化通知观察者
- 图示
二、简单实现
依照图示，上代码：首先是observer的接口类
/** * Created by 笑飞 on 2016/4/28. * 观察者，需要应用观察者模式时要实现此接口 */ public interface Observer { void onUpdate(); }
其次是observer的实现类
/** * Created by 笑飞 on 2016/4/28. */ public class ConcreteObserver implements Observer { private String myOnlyAttr; private int changeCount; /*刷新自己*/ @Override public void onUpdate() { myOnlyAttr = "通知Observer刷新了："+(changeCount++)+"次"; } public String getMyOnlyAttr() { return myOnlyAttr; } }
其次是subject的祖宗类
/** * Created by 笑飞 on 2016/4/28. * 发送者，需要应用观察者模式时的发送者要继承此类 */ public abstract class Subject { /*将一个被观察者对象和多个观察者对象绑定起来*/ protected List<Observer> observers = new ArrayList<>(); /*添加观察者，我们可能需要各种各样的观察者*/ public void attachObserver(Observer observer){ if (null ==observer){ throw new NullPointerException(); } if (!observers.contains(observer)){ observers.add(observer); } } public void detachObserver(Observer observer){ if (null ==observer){ throw new NullPointerException(); } if (observers.contains(observer)){ observers.remove(observer); } } public abstract void notifyObserverUpdate(); }
其次是subject的实现类：
/** * Created by 笑飞 on 2016/4/28. * 实现了刷新方法 */ public class ConcreteSubject extends Subject { @Override public void notifyObserverUpdate() { for (Observer observer :observers){ observer.onUpdate(); } } }
然后是activity的测试部分
public class MainActivity extends AppCompatActivity { private ConcreteSubject subject; private TextView textView; ConcreteObserver observer; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); textView = (TextView) findViewById(R.id.text); observer = new ConcreteObserver(); subject = new ConcreteSubject(); /*绑定观察者*/ subject.attachObserver(observer); } public void update(View v){ /*通知观察者刷新*/ subject.notifyObserverUpdate(); textView.setText(observer.getMyOnlyAttr()); } }
在开始第三部分之前，我们要注意，如果把上面的observer换成listview，把subject换成adapter，是不是我们经常看到和用到的listview的用法？其实 listview内置了observer，而adpter中内置了subject，换言之，listview和adapter其实就是观察者与被观察者的“形象代言人”。
好了，接下啦让我们以android中的经典ArrayAdapter来开始第三部分的分析吧！
三、android中listview的具体实现
- listview中的observer
public void setAdapter(ListAdapter adapter) { if (null != mAdapter) { mAdapter.unregisterDataSetObserver(mDataSetObserver); // 关键的成员变量，继承自AbsListView，等下去看看AbsListView关于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; if (mAdapter != null) { mAreAllItemsSelectable = mAdapter.areAllItemsEnabled(); mOldItemCount = mItemCount; mItemCount = mAdapter.getCount(); checkFocus(); mDataSetObserver = new AdapterDataSetObserver(); mAdapter.registerDataSetObserver(mDataSetObserver); // 在这里进行注册，注册为发送者adapter的观察者 mRecycler.setViewTypeCount(mAdapter.getViewTypeCount()); int position; if (mStackFromBottom) { position = lookForSelectablePosition(mItemCount - 1, false); } else { position = lookForSelectablePosition(0, true); } setSelectedPositionInt(position); setNextSelectedPositionInt(position); if (mItemCount == 0) { // Nothing selected checkSelectionChanged(); } if (mChoiceMode != CHOICE_MODE_NONE && mAdapter.hasStableIds() && mCheckedIdStates == null) { mCheckedIdStates = new LongSparseArray<Boolean>(); } } else { mAreAllItemsSelectable = true; checkFocus(); // Nothing selected checkSelectionChanged(); } if (mCheckStates != null) { mCheckStates.clear(); } if (mCheckedIdStates != null) { mCheckedIdStates.clear(); } requestLayout(); } }
mDataSetObserver这个观察者在AbsListView中：
AdapterDataSetObserver mDataSetObserver; // mDataSetObserver就是在这里定义的。那我们再看看AdapterDataSetObserver是什么类型的数据，看看当数据发生变化的时候，该类会进行什么样的动作。
接下来去AdapterView中，发现AdapterDataSetObserver是其一个内部类：
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(); // 这里是关键：这就是为什么数据发生了变化，视图可以随之变换的原因，因为它会调用框架，来进行重新绘制。最终调用的代码看紧接着的代码 } @Override public void onInvalidated() { mDataChanged = true; if (AdapterView.this.getAdapter().hasStableIds()) { // Remember the current state for the case where our hosting activity is being // stopped and later restarted mInstanceState = AdapterView.this.onSaveInstanceState(); } // Data is invalid so we should reset our state mOldItemCount = mItemCount; mItemCount = 0; mSelectedPosition = INVALID_POSITION; mSelectedRowId = INVALID_ROW_ID; mNextSelectedPosition = INVALID_POSITION; mNextSelectedRowId = INVALID_ROW_ID; mNeedSync = false; checkSelectionChanged(); checkFocus(); requestLayout(); } public void clearSavedState() { mInstanceState = null; } }
- ArrayAdapter中的subject(发送者，google大神命名为Observable，较为贴切)
在ArrayAdapter中:
@Override public void notifyDataSetChanged() { super.notifyDataSetChanged(); // 关键代码，这个notifyDataSetChanged()是从父类BaseAdapter继承过来的，所以看看在父类中它干了些什么 mNotifyOnChange = true; }
然后在BaseAdapter中：
private final DataSetObservable mDataSetObservable = new DataSetObservable();
//这对方法用来注册或注销从属ArrayAdapter的观察者，从此以后，adapter就成了发送者（Observable）的代理人 public void registerDataSetObserver(DataSetObserver observer) { mDataSetObservable.registerObserver(observer); } public void unregisterDataSetObserver(DataSetObserver observer) { mDataSetObservable.unregisterObserver(observer); }
public void notifyDataSetChanged() {
mDataSetObservable.notifyChanged(); // 关键代码：说明调的是成员变量mDataSetObservable的方法，所以进入DataSetObservable看看具体是如何操作的
}
接下来看发送者和发送者的祖宗，是不是很熟悉了？请自行与第二部分的发送者对应：
public class DataSetObservable extends Observable<DataSetObserver> { /** * Invokes onChanged on each observer. Called when the data set being observed has * changed, and which when read contains the new state of the data. */ public void notifyChanged() { synchronized(mObservers) { for (DataSetObserver observer : mObservers) { // 这里的mObservers是哪来的呢?继续追踪，但首先可以判断是来自Observable<DataSetObserver>的。进入看看 observer.onChanged(); } } } /** * Invokes onInvalidated on each observer. Called when the data set being monitored * has changed such that it is no longer valid. */ public void notifyInvalidated() { synchronized (mObservers) { for (DataSetObserver observer : mObservers) { observer.onInvalidated(); } } } }
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>(); 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(); } } }
总结：观察者模式看起来很高大上，其实说白了就是一个类维护了另一个类的一个集合，并通过这个集合绑定解绑或调用另一个类的方法，只不过，在设计底层框架时候，利用了多态的特性抽象出了接口和抽象类，以便适用于各种场合。其实在做终端页面时候完全用不到，因为多态只能增加运行时开销。然而，设置一个庞大系统时候，这种设计模式在面向对象的编程语言，可谓不能不用的手段了。