设计模式之观察者模式 Observer

字数 1129阅读 487

原理

观察者模式又称为发布/订阅(Publish/Subscribe)模式,因此我们可以用Android weekly网站的邮件订阅模式来形象的说明:

  1. Android Weekly每周收集优秀文章.。
  2. 你订阅了该网站的邮件推送服务,那么只要Android Weekly每周有更新,就会通知你的邮箱上
  3. 如果你不想再接受邮件,可以取消订阅,这样,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也不易,感谢支持