生活中我们常认定某些人很有才，但什么是有才呢？明朝的王守仁曾这样解释：才，是所谓天理，应用到物上，便成了才。凡事凡物，只要掌握了所谓科学的方法，并能灵活运用，那么你也可以成为一个有才的人。
观察者模式是软件设计都会运用到的一种模式，无论何种预言，由于本人是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();
}
}
}
总结：观察者模式看起来很高大上，其实说白了就是一个类维护了另一个类的一个集合，并通过这个集合绑定解绑或调用另一个类的方法，只不过，在设计底层框架时候，利用了多态的特性抽象出了接口和抽象类，以便适用于各种场合。其实在做终端页面时候完全用不到，因为多态只能增加运行时开销。然而，设置一个庞大系统时候，这种设计模式在面向对象的编程语言，可谓不能不用的手段了。