Android设计模式系列--观察者模式

观察者模式，是一种非常常见的设计模式，在很多系统中随处可见，尤其是涉及到数据状态发生变化需要通知的情况下。
本文以AbstractCursor为例子，展开分析。
观察者模式，Observer Pattern,是一个很实用的模式，本人曾经接触到的各种平台以及曾经参与项目中打印模板解释器中都用到了此模式。

1.意图
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
热门词汇：依赖 发布-订阅 事件 通知 更新 监听 

2.结构

这是一个最简单的观察者模式，目标对象能够添加和删除观察者，当自己某种状态或者行为发生改变时，可通过notify通知注册的观察者进行更新操作。
分析AbstractCursor的具体情况，我们发现实际工作有时需要对观察者进行统一管理，甚至观察者类型有很多种而又可以分成几个系列，这个时候是要复杂的多，通过合理的分层这个问题很好解决。下面根据具体情况，我们画出android中abstractCurosr中用到的观察者模式结构图：

观察者分成了两个系列。

3.代码
列举其中相关核心代码如下：

1. public abstract class AbstractCursor {  
2.     //定义管理器  
3.     DataSetObservable mDataSetObservable = new DataSetObservable();  
4.     ContentObservable mContentObservable = new ContentObservable();  
5.        
6.     //注册和卸载两类观察者  
7.     public void registerContentObserver(ContentObserver observer) {  
8.         mContentObservable.registerObserver(observer);  
9.     }  
10.    
11.     public void unregisterContentObserver(ContentObserver observer) {  
12.         // cursor will unregister all observers when it close  
13.         if (!mClosed) {  
14.             mContentObservable.unregisterObserver(observer);  
15.         }  
16.     }  
17.    
18.     public void registerDataSetObserver(DataSetObserver observer) {  
19.         mDataSetObservable.registerObserver(observer);  
20.            
21.     }  
22.    
23.     public void unregisterDataSetObserver(DataSetObserver observer) {  
24.         mDataSetObservable.unregisterObserver(observer);  
25.     }  
26.    
27.     //2类通知方法  
28.     protected void onChange(boolean selfChange) {  
29.         synchronized (mSelfObserverLock) {  
30.             mContentObservable.dispatchChange(selfChange);  
31.             if (mNotifyUri != null && selfChange) {  
32.                 mContentResolver.notifyChange(mNotifyUri, mSelfObserver);  
33.             }  
34.         }  
35.     }  
36.    
37.     protected void notifyDataSetChange() {  
38.         mDataSetObservable.notifyChanged();  
39.     }  
40. }  

再看看Observable<T>类和DataSetObservable类:

1. public abstract class Observable<T> {  
2.     /**  
3.      * 观察者列表  
4.      */ 
5.     protected final ArrayList<T> mObservers = new ArrayList<T>();  
6.    
7.     public void registerObserver(T observer) {  
8.         if (observer == null) {  
9.             throw new IllegalArgumentException("The observer is null.");  
10.         }  
11.         synchronized(mObservers) {  
12.             if (mObservers.contains(observer)) {  
13.                 throw new IllegalStateException("Observer " + observer + " is already registered.");  
14.             }  
15.             mObservers.add(observer);  
16.         }  
17.     }  
18.    
19.    
20.     public void unregisterObserver(T observer) {  
21.         if (observer == null) {  
22.             throw new IllegalArgumentException("The observer is null.");  
23.         }  
24.         synchronized(mObservers) {  
25.             int index = mObservers.indexOf(observer);  
26.             if (index == -1) {  
27.                 throw new IllegalStateException("Observer " + observer + " was not registered.");  
28.             }  
29.             mObservers.remove(index);  
30.         }  
31.     }  
32.        
33.     public void unregisterAll() {  
34.         synchronized(mObservers) {  
35.             mObservers.clear();  
36.         }          
37.     }  
38. }  

和

1. public class DataSetObservable extends Observable<DataSetObserver> {  
2.     /**  
3.      * 数据发生变化时，通知所有的观察者  
4.      */ 
5.     public void notifyChanged() {  
6.         synchronized(mObservers) {  
7.             for (DataSetObserver observer : mObservers) {  
8.                 observer.onChanged();  
9.             }  
10.         }  
11.     }  
12.     //... ... (其他方法)  
13. }  

观察者DataSetObserver类是一个抽象类：

1. public abstract class DataSetObserver {  
2.     public void onChanged() {  
3.         // Do nothing  
4.     }  
5. }  

所以我们具体看它的子类：

1. public class AlphabetIndexer extends DataSetObserver{  
2.     /*  
3.      * @hide 被android系统隐藏起来了  
4.      */ 
5.     @Override 
6.     public void onChanged() {  
7.         //观察到数据变化，观察者做自己该做的事情  
8.         super.onChanged();  
9.         mAlphaMap.clear();  
10.     }  
11. }  

ContentObserver也是类似。

4.效果
(1).行为型模式
(2).目标和观察者间的抽象耦合(经典实现)。
(3).支持广播通信(相信这点android开发者看到后应该有启发吧)。
(4).注意意外的更新，这也是观察者更新进行管理的原因之一。