android適配器中的觀察者模式

1. 模式介紹

模式的定義

定義對象間一種一對多的依賴關系，使得每當一個對象改變狀態，則所有依賴於它的對象都會得到通知並被自動更新。

模式的使用場景

• 關聯行為場景。需要注意的是，關聯行為是可拆分的，而不是“組合”關系；
• 事件多級觸發場景；
• 跨系統的消息交換場景，如消息隊列、事件總線的處理機制。

2. UML類圖

角色介紹

• 抽象主題 (Subject) 角色
  抽象主題角色把所有觀察者對象的引用保存在一個聚集（比如ArrayList對象）裡，每個主題都可以有任意數量的觀察者。抽象主題提供一個接口，可以增加和刪除觀察者對象，抽象主題角色又叫做抽象被觀察者(Observable)角色。

• 具體主題 (ConcreteSubject) 角色
  將有關狀態存入具體觀察者對象；在具體主題的內部狀態改變時，給所有登記過的觀察者發出通知。具體主題角色又叫做具體被觀察者(Concrete Observable)角色。

• 抽象觀察者 (Observer) 角色
  為所有的具體觀察者定義一個接口，在得到主題的通知時更新自己，這個接口叫做更新接口。

• 具體觀察者 (ConcreteObserver) 角色

存儲與主題的狀態自恰的狀態。具體觀察者角色實現抽象觀察者角色所要求的更新接口，以便使本身的狀態與主題的狀態 像協調。如果需要，具體觀察者角色可以保持一個指向具體主題對象的引用。

三.ListView中觀察者模式的使用—繼承AdapterView,組合ListAdapter       private void initView() {
mListView = (ListView) findViewById(R.id.list_view);
findViewById(R.id.update_tv).setOnClickListener(this);

mDataList = new ArrayList();
String title = null;
for (int i = 0; i < 20; i++) {
title = new String("title_" + i);
mDataList.add(title);
}
mAdapter = new DataAdapter(this, mDataList);
mListView.setAdapter(mAdapter);

mAdapter.notifyDataSetChanged();
}
@Override
public void onClick(View v) {

if (v.getId() == R.id.update_tv) {
int len = mDataList.size();
int index = new Random().nextInt(len);
mDataList.set(index, "updata_" + index);

mAdapter.notifyDataSetChanged();
}
}   那麼我們需要知道mAdapter.notifyDataSetChanged();具體的實現   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);
}

public void unregisterDataSetObserver(DataSetObserver observer) {
mDataSetObservable.unregisterObserver(observer);
}

/**
* 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 class DataSetObservable extends Observable {
/**
* 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();
}
}
} 。。。 } 其被觀察者(事件源)Observable基類的定義為 /**
* Provides methods for registering or unregistering arbitrary observers in an {@link ArrayList}.
*
* This abstract class is intended to be subclassed and specialized to maintain
* a registry of observers of specific types and dispatch notifications to them.
*
* @param T The observer type.
*/
public abstract class Observable {
/**
* The list of observers. An observer can be in the list at most
* once and will never be null.
*/
protected final ArrayList mObservers = new ArrayList();

/**
* 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);
}
} } 到此我們已經知道mAdapter.notifyDataSetChanged();最終是Observable遍歷注冊的觀察者對象集合，執行DataSetObserver.onChanged()。 那麼我們就要查看源碼看下該觀察者被注冊到事件源的 直接查看ListView.setAdapter()方法的源碼實現 @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);
} 。。。
requestLayout();
} 可以看到在mAdapter.registerDataSetObserver(mDataSetObserver);中已經將觀察者對象注冊到事件源對象中了。其中mDataSetObserver對象是聲明在父類AbsListView中AdapterDataSetObserver mDataSetObserver；而AdapterDataSetObserver的定義是在AdapterView的內部類中。   public abstract class AdapterView extends ViewGroup {


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

}

。。。 } }

ListView中觀察者模式的使用—數據變化通知界面更新的流程

1）ListView繼承自AdapterView（其中包含內部類AdapterDataSetObserver）

2）當ListView調用setAdapter(ListAdapteradapter)時，將生成觀察者實例（ListView充當了觀察者角色），並注冊到mAdapter中（ListAdapter充當了被觀察者角色）。

mDataSetObserver= new AdapterDataSetObserver();

mAdapter.registerDataSetObserver(mDataSetObserver);

3）Adapter中數據變化時，將調用mAdapter.notifyDataSetChanged()，實際調用的是mDataObservable的notifyChanged()，其內部將執行每一個observer的onChanged()，也就達到了更新界面的效果。

觀察者模式最佳實踐

項目實踐中典型的觀察者模式框架：EventBus、RxJava、KVC/KVO（iOS）

 

 

小結

1 .為什麼引入設計模式？

使用設計模式有助於軟件適應變化，增強可維護性、可復用性。

設計模式遵循的六大設計原則：SOLID+LawofDemeter。“高內聚、低耦合”

2.觀察者模式主要作用就是解耦。

將觀察者和被觀察者進行隔離，只依賴於Observer和Observable抽象。

3.Android中的源代碼，有助於我們理解觀察者模式的編碼實現方式，理解Listview界面更新的背後邏輯。

4.觀察者模式最佳實踐：EventBus、RxJava、KVC/KVO