原理
观察者模式又称为发布/订阅(Publish/Subscribe)模式,因此我们可以用Android weekly网站的邮件订阅模式来形象的说明:
- Android Weekly每周收集优秀文章.。
- 你订阅了该网站的邮件推送服务，那么只要Android Weekly每周有更新,就会通知你的邮箱上
- 如果你不想再接受邮件，可以取消订阅，这样，Android Weekl发布更新就不会再通知你。
其实以上的概念，就可以理解为观察者模式。观察者模式中有主题(Subject)和观察者(Observer)，分别对应Android Weekly和订阅用户(你)。观察者模式定义了对象之间的一对多的依赖关系，这样，当"一"的一方状态发生变化时，它所依赖的"多"的一方都会收到通知并且自动更新。如图：
observable.png
实现方式
简单实现
被观察者和观察者接口定义
public interface Subject {
/**
* 添加观察者
* @param obj
*/
void addObserver(Observer obj);
/**
* 移除观察者
* @param obj
*/
void deleteObserver(Observer obj);
/**
* 当主题方法改变时,这个方法被调用,通知所有的观察者
*/
void notifyChange();
}
public interface Observer {
/**
* 当被观察者状态改变时,传递内容data给观察者,每个观察者都需要实现该方法
* @param data 更新内容
*/
void update(String data);
}
被观察者Android Weekly和观察者订阅用户的接口实现
public class AndroidWeeklySubject implements Subject {
private List<Observer> observers = new ArrayList<Observer>();
private String data;
@Override
public void addObserver(Observer obj) {
observers.add(obj);
}
@Override
public void deleteObserver(Observer obj) {
int i = observers.indexOf(obj);
if (i >= 0) {
observers.remove(obj);
}
}
@Override
public void notifyChange() {
for (Observer observer : observers) {
observer.update(data);
}
}
/**
* 发布新一周的内容
*
* @param info
*/
public void send(String info) {
this.data = info;
System.out.println("这周的新期刊:" + info);
this.notifyChange();
}
}
以及测试和测试结果
private static void observerTest() {
AndroidWeeklySubject subject = new AndroidWeeklySubject();
subject.addObserver(new ReaderObserver("小明"));
subject.addObserver(new ReaderObserver("大明"));
subject.addObserver(new ReaderObserver("小红"));
subject.addObserver(new ReaderObserver("大红"));
subject.send("《观察者模式从入门到放弃》");
}
这周的新期刊:《观察者模式从入门到放弃》
小明 正在阅读新一期的Android weekly:《观察者模式从入门到放弃》
大明 正在阅读新一期的Android weekly:《观察者模式从入门到放弃》
小红 正在阅读新一期的Android weekly:《观察者模式从入门到放弃》
大红 正在阅读新一期的Android weekly:《观察者模式从入门到放弃》
而在Android上我们最常见的观察者就是ContentObserver，对数据库数据变化的监听。对于众多的三方应用怎么告知他们数据库变化，比如常见的短信，联系人，观察者模式是比较好的，先简单看看使用方式，
// 定义我们观察者
class StepsContentObserver extends ContentObserver {
StepsContentObserver() {
super(new Handler());
}
@Override
public void onChange(boolean selfChange) {
super.onChange(selfChange);
...
}
}
// 声明一个ContentObserver 观察者
ContentObserver stepObserver = new StepsContentObserver();
// 将观察者订阅到指定的CONTENT_URI上，true表示迷糊匹配
getContentResolver().registerContentObserver(CONTENT_URI, true, stepObserver);
// 取消订阅
getContentResolver().unregisterContentObserver(stepObserver);
常见的三部曲，用起来很简单，我们在 onChange回调里处理变化的数据就可以了
ContentObserver 观察者实现分析
ContentObserver代码不多，分析关键的代码
源码在/frameworks/base/core/java/android/database/ContentObserver.java
private final Object mLock = new Object();
private Transport mTransport; // guarded by mLock
Handler mHandler;
private void dispatchChange(boolean selfChange, Uri uri, int userId) {
if (mHandler == null) {
onChange(selfChange, uri, userId);
} else {
mHandler.post(new NotificationRunnable(selfChange, uri, userId));
}
}
onChange方法在 dispatchChange 里被执行，关键的地方在 dispatchChange在什么情况下会被执行。
接着看，ContentObserver里有个静态内部类，实现了IContentObserver.Stub，所以我们也就清楚了是通过AIDL跨进程的方式告知我们数据库发生了变化。
private static final class Transport extends IContentObserver.Stub {
private ContentObserver mContentObserver;
public Transport(ContentObserver contentObserver) {
mContentObserver = contentObserver;
}
@Override
public void onChange(boolean selfChange, Uri uri, int userId) {
ContentObserver contentObserver = mContentObserver;
if (contentObserver != null) {
contentObserver.dispatchChange(selfChange, uri, userId);
}
}
public void releaseContentObserver() {
mContentObserver = null;
}
}
Subject 订阅者实现分析
Android 内部是实现对数据库的监听的订阅者又是如何实现的呢？我们来研究一下。
首先我们通过 getContentResolver().registerContentObserver(CONTENT_URI, true, stepObserver); 来订阅观察者，所以我们从ContentResolver这里入手。
public final void registerContentObserver(Uri uri, boolean notifyForDescendents,
ContentObserver observer, int userHandle) {
try {
getContentService().registerContentObserver(uri, notifyForDescendents,
observer.getContentObserver(), userHandle);
} catch (RemoteException e) {
}
}
通过getContentService()拿到 IContentService 的AIDL接口实现，原理是 Binder的跨进程通信，我们这就不细说了。我们找到他的实现
/frameworks/base/services/core/java/com/android/server/content/ContentService.java
registerContentObserver方法
@Override
public void registerContentObserver(Uri uri, boolean notifyForDescendants,
IContentObserver observer, int userHandle) {
if (observer == null || uri == null) {
throw new IllegalArgumentException("You must pass a valid uri and observer");
}
enforceCrossUserPermission(userHandle,
"no permission to observe other users' provider view");
if (userHandle < 0) {
if (userHandle == UserHandle.USER_CURRENT) {
userHandle = ActivityManager.getCurrentUser();
} else if (userHandle != UserHandle.USER_ALL) {
throw new InvalidParameterException("Bad user handle for registerContentObserver: "
+ userHandle);
}
}
synchronized (mRootNode) {
mRootNode.addObserverLocked(uri, observer, notifyForDescendants, mRootNode,
Binder.getCallingUid(), Binder.getCallingPid(), userHandle);
if (false) Log.v(TAG, "Registered observer " + observer + " at " + uri +
" with notifyForDescendants " + notifyForDescendants);
}
}
关键的代码在 mRootNode.addObserverLocked。ObserverNode 是ContentService的一个静态内部类，封装了对观察者进行订阅，取消订阅等方法，而观察者信息则被封装在ObserverNode的内部类 ObserverEntry 里。当数据变化时就是通过ObserverNode发送消息，订阅观察者的方法如下
private ArrayList<ObserverEntry> mObservers = new ArrayList<ObserverEntry>();
private void addObserverLocked(Uri uri, int index, IContentObserver observer,
boolean notifyForDescendants, Object observersLock,
int uid, int pid, int userHandle) {
// If this is the leaf node add the observer
if (index == countUriSegments(uri)) {
mObservers.add(new ObserverEntry(observer, notifyForDescendants, observersLock,
uid, pid, userHandle));
return;
}
// Look to see if the proper child already exists
String segment = getUriSegment(uri, index);
if (segment == null) {
throw new IllegalArgumentException("Invalid Uri (" + uri + ") used for observer");
}
int N = mChildren.size();
for (int i = 0; i < N; i++) {
ObserverNode node = mChildren.get(i);
if (node.mName.equals(segment)) {
node.addObserverLocked(uri, index + 1, observer, notifyForDescendants,
observersLock, uid, pid, userHandle);
return;
}
}
// No child found, create one
ObserverNode node = new ObserverNode(segment);
mChildren.add(node);
node.addObserverLocked(uri, index + 1, observer, notifyForDescendants,
observersLock, uid, pid, userHandle);
}
这里的实现是递归，最终将观察者添加到 mObservers 集合里，到这里就完成订阅了。
数据变化通知
变化的通知最终实现是在 ContentSerivce 的notifyChange方法里，调用封装的ObserverCall方法 oc.mObserver.onChange(oc.mSelfChange, uri, userHandle)
/**
* Notify observers of a particular user's view of the provider.
* @param userHandle the user whose view of the provider is to be notified. May be
* the calling user without requiring any permission, otherwise the caller needs to
* hold the INTERACT_ACROSS_USERS_FULL permission. Pseudousers USER_ALL and
* USER_CURRENT are properly interpreted; no other pseudousers are allowed.
*/
@Override
public void notifyChange(Uri uri, IContentObserver observer,
boolean observerWantsSelfNotifications, boolean syncToNetwork,
int userHandle) {
try {
ArrayList<ObserverCall> calls = new ArrayList<ObserverCall>();
synchronized (mRootNode) {
mRootNode.collectObserversLocked(uri, 0, observer, observerWantsSelfNotifications,
userHandle, calls);
}
final int numCalls = calls.size();
for (int i=0; i<numCalls; i++) {
ObserverCall oc = calls.get(i);
try {
oc.mObserver.onChange(oc.mSelfChange, uri, userHandle);
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "Notified " + oc.mObserver + " of " + "update at " + uri);
}
} catch (RemoteException ex) {
...
}
而往上看是在ContentResolver 里调用 ContentService的 notifiyChange 方法通知各个ObserverEntry，完成消息的通知。
/**
* Notify registered observers within the designated user(s) that a row was updated.
*
* @hide
*/
public void notifyChange(Uri uri, ContentObserver observer, boolean syncToNetwork,
int userHandle) {
try {
getContentService().notifyChange(
uri, observer == null ? null : observer.getContentObserver(),
observer != null && observer.deliverSelfNotifications(), syncToNetwork,
userHandle);
} catch (RemoteException e) {
}
}
在往上呢？就找不到具体调用地方了。不过找到一个说明，也就是和数据库相关的 ContentProvider。
可以看到在 ContentProvider的增删改等修改操作执行的时候，建议我们调用 ContentResolver#notifyChange(android.net.Uri ,android.database.ContentObserver) notifyChange()}方法。也就是在子类的ContentProvider实现里完成消息的通知的。
/**
* Implement this to handle requests to update one or more rows.
* The implementation should update all rows matching the selection
* to set the columns according to the provided values map.
* As a courtesy, call {@link ContentResolver#notifyChange(android.net.Uri ,android.database.ContentObserver) notifyChange()}
* after updating.
* This method can be called from multiple threads, as described in
* <a href="{@docRoot}guide/topics/fundamentals/processes-and-threads.html#Threads">Processes
* and Threads</a>.
*
* @param uri The URI to query. This can potentially have a record ID if this
* is an update request for a specific record.
* @param values A set of column_name/value pairs to update in the database.
* This must not be {@code null}.
* @param selection An optional filter to match rows to update.
* @return the number of rows affected.
*/
public abstract int update(Uri uri, ContentValues values, String selection,
String[] selectionArgs);
观察者模式的内容就这些了，而ContentProvider的原理我们就不在这里阐述了。
总结
观察者模式提供了一种低耦合的面向对象设计。被观察者不用关心观察者的实现方式，只要知道有观察者订阅了我就可以了，这样的话，改变被观察者或者观察者其中一方，并不会影响另一方，只要他们之间的接口关系没有变化，就可以自由地修改他们的实现方式。
在SDK开发中，也是经常会使用到的一种设计模式，用来降低耦合，开发者不用关心内部实现，接入SDK即可。
code不易，write也不易，感谢支持
