設計模式（一）觀察者模式
1.觀察者模式模式簡介
定義：
觀察者模式（又被稱為發布-訂閱（Publish/Subscribe）模式，屬于行為型模式的一種，它定義了一種一對多的依賴關系，讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態變化時，會通知所有的觀察者對象，使他們能夠自動更新自己。
觀察者模式結構圖：
- Subject：抽象主題（抽象被觀察者），抽象主題角色把所有觀察者對象保存在一個集合里，每個主題都可以有任意數量的觀察者，抽象主題提供一個接口，可以增加和刪除觀察者對象。
- ConcreteSubject：具體主題（具體被觀察者），該角色將有關狀態存入具體觀察者對象，在具體主題的內部狀態發生改變時，給所有注冊過的觀察者發送通知。
- Observer：抽象觀察者，是觀察者者的抽象類，它定義了一個更新接口，使得在得到主題更改通知時更新自己。
- ConcrereObserver：具體觀察者，是實現抽象觀察者定義的更新接口，以便在得到主題更改通知時更新自身的狀態。
2.觀察者模式簡單實現
觀察者模式這種發布-訂閱的形式我們可以拿微信公眾號來舉例，假設微信用戶就是觀察者，微信公眾號是被觀察者，有多個的微信用戶關注了程序猿這個公眾號，當這個公眾號更新時就會通知這些訂閱的微信用戶。好了我們來看看用代碼如何實現：
抽象觀察者（Observer）
里面定義了一個更新的方法：
public interface Observer { public void update(String message); }
具體觀察者（ConcrereObserver）
微信用戶是觀察者，里面實現了更新的方法：
1 public class WeixinUser implements Observer { 2 // 微信用戶名 3 private String name; 4 public WeixinUser(String name) { 5 this.name = name; 6 } 7 @Override 8 public void update(String message) { 9 System.out.println(name + "-" + message); 10 } 11 12 }
抽象被觀察者（Subject）
抽象主題，提供了attach、detach、notify三個方法：
1 public interface Subject { 2 /** 3 * 增加訂閱者 4 * @param observer 5 */ 6 public void attach(Observer observer); 7 /** 8 * 刪除訂閱者 9 * @param observer 10 */ 11 public void detach(Observer observer); 12 /** 13 * 通知訂閱者更新消息 14 */ 15 public void notify(String message); 16 }
具體被觀察者（ConcreteSubject）
微信公眾號是具體主題（具體被觀察者），里面存儲了訂閱該公眾號的微信用戶，并實現了抽象主題中的方法：
1 public class SubscriptionSubject implements Subject { 2 //儲存訂閱公眾號的微信用戶 3 private List<Observer> weixinUserlist = new ArrayList<Observer>(); 4 5 @Override 6 public void attach(Observer observer) { 7 weixinUserlist.add(observer); 8 } 9 10 @Override 11 public void detach(Observer observer) { 12 weixinUserlist.remove(observer); 13 } 14 15 @Override 16 public void notify(String message) { 17 for (Observer observer : weixinUserlist) { 18 observer.update(message); 19 } 20 } 21 }
客戶端調用
1 public class Client { 2 public static void main(String[] args) { 3 SubscriptionSubject mSubscriptionSubject=new SubscriptionSubject(); 4 //創建微信用戶 5 WeixinUser user1=new WeixinUser("楊影楓"); 6 WeixinUser user2=new WeixinUser("月眉兒"); 7 WeixinUser user3=new WeixinUser("紫軒"); 8 //訂閱公眾號 9 mSubscriptionSubject.attach(user1); 10 mSubscriptionSubject.attach(user2); 11 mSubscriptionSubject.attach(user3); 12 //公眾號更新發出消息給訂閱的微信用戶 13 mSubscriptionSubject.notify("劉望舒的專欄更新了"); 14 } 15 } 16 17 結果： 18 19 楊影楓-劉望舒的專欄更新了 20 月眉兒-劉望舒的專欄更新了 21 紫軒-劉望舒的專欄更新了
3.使用觀察者模式的場景和優缺點
使用場景
- 關聯行為場景，需要注意的是，關聯行為是可拆分的，而不是“組合”關系。
- 事件多級觸發場景。
- 跨系統的消息交換場景，如消息隊列、事件總線的處理機制。
優點
解除耦合，讓耦合的雙方都依賴于抽象，從而使得各自的變換都不會影響另一邊的變換。
缺點
在應用觀察者模式時需要考慮一下開發效率和運行效率的問題，程序中包括一個被觀察者、多個觀察者，開發、調試等內容會比較復雜，而且在Java中消息的通知一般是順序執行，那么一個觀察者卡頓，會影響整體的執行效率，在這種情況下，一般會采用異步實現。
4.Android中的觀察者模式
android源碼中也有很多使用了觀察者模式，比如OnClickListener、ContentObserver、android.database.Observable等；還有組件通訊庫RxJava、RxAndroid、EventBus；在這里將拿我們最常用的Adapter的notifyDataSetChanged()方法來舉例：
當我們用ListView的時候，數據發生變化的時候我們都會調用Adapter的notifyDataSetChanged()方法，這個方法定義在BaseAdaper中，我們來看看BaseAdaper的部分源碼：
1 public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter { 2 3 //數據集觀察者 4 private final DataSetObservable mDataSetObservable = new DataSetObservable(); 5 6 public boolean hasStableIds() { 7 return false; 8 } 9 10 public void registerDataSetObserver(DataSetObserver observer) { 11 mDataSetObservable.registerObserver(observer); 12 } 13 14 public void unregisterDataSetObserver(DataSetObserver observer) { 15 mDataSetObservable.unregisterObserver(observer); 16 } 17 18 /** 19 * 當數據集變化時，通知所有觀察者 20 */ 21 public void notifyDataSetChanged() { 22 mDataSetObservable.notifyChanged(); 23 }
很明顯BaseAdapter用的是觀察者模式，BaseAdapter是具體被觀察者，接下來看看mDataSetObservable.notifyChanged()：
1 public class DataSetObservable extends Observable<DataSetObserver> { 2 public void notifyChanged() { 3 synchronized(mObservers) { 4 for (int i = mObservers.size() - 1; i >= 0; i--) { 5 mObservers.get(i).onChanged(); 6 } 7 } 8 }
我們看到了mObservers，這就是觀察者的集合，這些觀察者是在ListView通過setAdaper()設置Adaper時產生的：
1 @Override 2 public void setAdapter(ListAdapter adapter) { 3 if (mAdapter != null && mDataSetObserver != null) { 4 mAdapter.unregisterDataSetObserver(mDataSetObserver); 5 } 6 ... 7 super.setAdapter(adapter); 8 9 if (mAdapter != null) { 10 mAreAllItemsSelectable = mAdapter.areAllItemsEnabled(); 11 mOldItemCount = mItemCount; 12 mItemCount = mAdapter.getCount(); 13 checkFocus(); 14 //創建數據觀察者 15 mDataSetObserver = new AdapterDataSetObserver(); 16 //注冊觀察者 17 mAdapter.registerDataSetObserver(mDataSetObserver); 18 19 ... 20 }
接下來看看觀察者AdapterDataSetObserver中處理了什么：
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 10 @Override 11 public void onInvalidated() { 12 super.onInvalidated(); 13 if (mFastScroller != null) { 14 mFastScroller.onSectionsChanged(); 15 } 16 } 17 }
從上面的代碼看不出什么，再看看AdapterDataSetObserver的父類AdapterView的AdapterDataSetObserver：
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 (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null 9 && mOldItemCount == 0 && mItemCount > 0) { 10 AdapterView.this.onRestoreInstanceState(mInstanceState); 11 mInstanceState = null; 12 } else { 13 rememberSyncState(); 14 } 15 checkFocus(); 16 //重新布局 17 requestLayout(); 18 } 19 20 ... 21 22 public void clearSavedState() { 23 mInstanceState = null; 24 } 25 }
我們看到在onChanged()方法中調用了requestLayout()方法來重新進行布局。好了，看到這里我們都明白了，當ListView的數據發生變化時，我們調用Adapter的notifyDataSetChanged()方法，這個方法又會調用觀察者們（AdapterDataSetObserver）的onChanged()方法，onChanged()方法又會調用requestLayout()方法來重新進行布局。
“標準答案”：觀察者模式定義了一種一對多的依賴關系，讓多個觀察者對象同時監聽某一個主題對象。觀察者模式完美的將觀察者和被觀察的對象分離開，一個對象的狀態發生變化時，所有依賴于它的對象都得到通知并自動刷新。
回調函數其實也算是一種觀察者模式的實現方式，回調函數實現的觀察者和被觀察者往往是一對一的依賴關系。
所以最明顯的區別是觀察者模式是一種設計思路，而回調函數式一種具體的實現方式；另一明顯區別是一對多還是多對多的依賴關系方面。
浙公網安備 33010602011771號