Android之观察者模式-白红宇

写在前面

以前听说过一句话，说是** 自己写过代码总量没有超过10w行谈设计模式那都是耍流氓 **。我信了，所以一直没怎么系统的看已经买了的《Android源码设计模式》。最近有个小伙伴在群里问recyclerview怎么刷新数据，以前大概也做过，流程也就是那么两步：1.更新Adapter里数据集的引用，让他指向最新的数据集。2.调用Adapter的notifyDataSetChanged()来更新ui。之后小伙伴又问了notifyDataSetChanged()到底如何更新ui的，当时只是看出了一个观察者模式，还有一些细节没想明白。而且讲真的观察者模式的应用还是非常多的，无论是Android还是最近很火的RxJava，其中都可以看到观察者模式的身影，所以决定这周把观察者模式撸一遍。

1、什么是观察者模式

观察者模式(Observer Pattern)定义了对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新，观察者模式又叫做发布-订阅(Publish/Subscribe)模式。

定义总是这么精准而抽象，让我们结合一些Android中的场景来简单的理解一下：在Android最常用的点击事件，我们会通过设置控件的OnClickListener并传入一个OnClickListener的实现类来回调点击事件。这种我们便可以将之看做一个观察者模式。我们的OnClickListener是观察者，被观察者是控件，当有点击事件的时候控件发布点击事件，观察者OnClickListener就会接收到点击事件。当然了，说到底，就是回调。

2、用回调写一个简单的观察者模式

首先我们想一个生活中的场景，来凑个观察者模式出来。平时我们要烧水吧，总要派个人看着，水烧开的时候把电源拔了装水。在这个场景里水壶就是被观察者(Observable)，观察者(Observer)就是人。首先我们用以上我说的，那玩意就是回调，用回调来写一个看看。那我们先写一个被观察者“水壶”来看看：

public class Kettle
    
      {    Observer
     
       o;    /**     * 发布信息     */    public void publishEvent(T t){        if (o == null)            throw new NullPointerException("you must regist Observer first!");        notifyData(t);    }    /**     * 通知订阅者     */    public void notifyData(T t){        o.receiverEvent(t);    }    /**     * 注册一个观察者     */    public void registObserver(Observer
      
        o){        this.o = o;    }    /**     * 在你需要的时候调用这个方法，防止内存泄露     */    public void unregistObserver(){        this.o = null;    }}复制代码

首先我们这个水壶是被观察者，内部肯定要维护一个观察者的引用，或者一个观察者队列的引用，方便我们进行回调，当然更多的事我们尽量不要通过Observer这个东西来做，在这个观察者模式中我希望Observer仅仅作为一个纯粹的回调。因为观察模式本身的特性之一就是解耦，如果你要通过Observer干更多的事无疑会加重Observable和Observer之间的耦合。更多信息可以看代码，我注释已经写得很详细了。

接下来看看上面提到的那个Observer我是咋写的：

public interface Observer
    
      {    void receiverEvent(T t);}复制代码

很简单的一个接口，写上泛型，嗯，顺便练习一下泛型...只有一个方法，用来回调。有接口那我们肯定要有实现类，我这个场景里说了，人是观察者，于是我写了一个Observer的实现类：

public abstract class People implements Observer
    
      {    @Override    public void receiverEvent(String s) {        System.out.println(s);        dealWithEvent();    }    /**     * 交给用户去处理事件     */    public abstract void dealWithEvent();}复制代码

我把这个People设计为一个抽象类，这样我可以在接收到这个事件的时候做一些简单的处理(把他打印出来……)，然后再把具体的逻辑交给这个抽象类的子类来做，我这逻辑比较简单，就没传什么参数进去了。最后免不了跑起来看看了~

public class Test {    public static void main(String[] args){        //水壶        Kettle
    
      kettle = new Kettle<>();                People people = new People() {            @Override            public void dealWithEvent() {                System.out.println("People:拔电源装水了~");            }        };        //注册观察者        kettle.registObserver(people);        //在一定条件下调用此方法发布事件        kettle.publishEvent("Kettle:水烧开了！再不拔电源我要炸了！");    }}复制代码

这里实现了一个加单的观察者模式，观察者也只能注册一个，不过例子么，简单的才容易看懂嘛~接下来看一下Java util里自带的Observable和Observer，看一下别人的套路~

3、Java中的观察者模式

在Java的util包里也有Observable和Observer那么这俩兄弟跟我们上面自己实现的有啥不同呢？首先还是那个水壶的例子，有了上面的基础，我就直接把所有的类和测试代码甩上来了，相信以各位看官的实力都是小case:

public class HelloWorld {    public static native String sayHello(String name);    public static void main(String[] args) {        //被观察者        Kettle kettle = new Kettle();        //观察者        PeopleLookKettle people = new PeopleLookKettle();        kettle.addObserver(people);        kettle.notifyPeople("kettle:水烧开了!再不拔电源我要炸了!!");    }}public class Kettle extends Observable {    public void notifyPeople(String str){        System.out.println("kettle:我是水壶~");        setChanged();        notifyObservers(str);    }}public class PeopleLookKettle implements Observer {    @Override    public void update(Observable o, Object arg) {        System.out.println((String) arg);        System.out.println("People:拔电源装水~");    }}复制代码

之后还是看一下运行结果

代码上完了，那么这里实现的观察模式又是个什么套路呢？不比比直接看源码，先从简单的Observer看起：

public interface Observer {    /**     * This method is called whenever the observed object is changed. An     * application calls an Observable object's     * notifyObservers method to have all the object's     * observers notified of the change.     *     * @param   o     the observable object.     * @param   arg   an argument passed to the notifyObservers     *                 method.     */    void update(Observable o, Object arg);}复制代码

我去，这跟我上面的设计不符啊...这货怎么把Observable传过来了...这只是设计类和接口的一些设计理念不一样，作为jdk他需要考虑各种兼容性和安全性的问题，所以不可能像我们客户端程序员一样，很多时候写的都非常任性。先不扯那么多，我们要看的是套路~这玩意是个接口，就像我说的那样，做个回调就行了，剩下的都交给实现类来操心。

看完了Observer我们再来看看Observable：

public class Observable {    private boolean changed = false;    private Vector
    
      obs;    /** Construct an Observable with zero Observers. */    public Observable() {        obs = new Vector<>();    }    /**     * Adds an observer to the set of observers for this object, provided     * that it is not the same as some observer already in the set.     * The order in which notifications will be delivered to multiple     * observers is not specified. See the class comment.     *     * @param   o   an observer to be added.     * @throws NullPointerException   if the parameter o is null.     */    public synchronized void addObserver(Observer o) {        if (o == null)            throw new NullPointerException();        if (!obs.contains(o)) {            obs.addElement(o);        }    }    /**     * Deletes an observer from the set of observers of this object.     * Passing 
     null to this method will have no effect.     * @param   o   the observer to be deleted.     */    public synchronized void deleteObserver(Observer o) {        obs.removeElement(o);    }    /**     * If this object has changed, as indicated by the     * 
     hasChanged method, then notify all of its observers     * and then call the 
     clearChanged method to     * indicate that this object has no longer changed.     * 
          * Each observer has its update method called with two     * arguments: this observable object and null. In other     * words, this method is equivalent to:     * 
     
           * notifyObservers(null)
     
     *     * @see     java.util.Observable#clearChanged()     * @see     java.util.Observable#hasChanged()     * @see     java.util.Observer#update(java.util.Observable, java.lang.Object)     */    public void notifyObservers() {        notifyObservers(null);    }    /**     * If this object has changed, as indicated by the     * 
     hasChanged method, then notify all of its observers     * and then call the 
     clearChanged method to indicate     * that this object has no longer changed.     * 
          * Each observer has its update method called with two     * arguments: this observable object and the arg argument.     *     * @param   arg   any object.     * @see     java.util.Observable#clearChanged()     * @see     java.util.Observable#hasChanged()     * @see     java.util.Observer#update(java.util.Observable, java.lang.Object)     */    public void notifyObservers(Object arg) {        /*         * a temporary array buffer, used as a snapshot of the state of         * current Observers.         */        Object[] arrLocal;        synchronized (this) {            /* We don't want the Observer doing callbacks into             * arbitrary code while holding its own Monitor.             * The code where we extract each Observable from             * the Vector and store the state of the Observer             * needs synchronization, but notifying observers             * does not (should not).  The worst result of any             * potential race-condition here is that:             * 1) a newly-added Observer will miss a             *   notification in progress             * 2) a recently unregistered Observer will be             *   wrongly notified when it doesn't care             */            if (!changed)                return;            arrLocal = obs.toArray();            clearChanged();        }        for (int i = arrLocal.length-1; i>=0; i--)            ((Observer)arrLocal[i]).update(this, arg);    }    /**     * Clears the observer list so that this object no longer has any observers.     */    public synchronized void deleteObservers() {        obs.removeAllElements();    }    /**     * Marks this Observable object as having been changed; the     * hasChanged method will now return true.     */    protected synchronized void setChanged() {        changed = true;    }    /**     * Indicates that this object has no longer changed, or that it has     * already notified all of its observers of its most recent change,     * so that the hasChanged method will now return false.     * This method is called automatically by the     * notifyObservers methods.     *     * @see     java.util.Observable#notifyObservers()     * @see     java.util.Observable#notifyObservers(java.lang.Object)     */    protected synchronized void clearChanged() {        changed = false;    }    /**     * Tests if this object has changed.     *     * @return  true if and only if the setChanged     *          method has been called more recently than the     *          clearChanged method on this object;     *          false otherwise.     * @see     java.util.Observable#clearChanged()     * @see     java.util.Observable#setChanged()     */    public synchronized boolean hasChanged() {        return changed;    }    /**     * Returns the number of observers of this Observable object.     *     * @return  the number of observers of this object.     */    public synchronized int countObservers() {        return obs.size();    }}复制代码

可以看出Observable内部使用了一个Vector来维护订阅的Observer，关于Vector这里不做更多的了解，在这就把他当做一个普通的Observer容器就行了。让我们看看和这个容器有关的套路，为了防止各位产生代码疲劳，我特意贴心的给各位截了个图23333333：

添加和删除Observer就是在容器obs里做增删操作，这套路很简单，不过为了线程安全加了个synchronized。之后看一下重点，通知Observers时调用的notifyObservers()，notifyObservers()最终会调用他自身带参的重载方法，看下代码：

public void notifyObservers(Object arg) {        /*         * a temporary array buffer, used as a snapshot of the state of         * current Observers.         */        Object[] arrLocal;        synchronized (this) {            /* We don't want the Observer doing callbacks into             * arbitrary code while holding its own Monitor.             * The code where we extract each Observable from             * the Vector and store the state of the Observer             * needs synchronization, but notifying observers             * does not (should not).  The worst result of any             * potential race-condition here is that:             * 1) a newly-added Observer will miss a             *   notification in progress             * 2) a recently unregistered Observer will be             *   wrongly notified when it doesn't care             */            if (!changed)                return;            arrLocal = obs.toArray();            clearChanged();        }        for (int i = arrLocal.length-1; i>=0; i--)            ((Observer)arrLocal[i]).update(this, arg);    }复制代码

先除去那大段的注释不看，这里就是拿到Observable内部维护的Observer容器，然后遍历回调这些Observer的update方法以实现让所有Observer收到通知。但是后面那段代码被执行是有条件的，就是Observable内部的changed字段为true才会执行，而这个字段只有通过setChanged()方法来将其值置为true。但是在上面的源码中我们可以发现这个方法是protected修饰的，所以不通过特殊手段的话，我们只有通过继承才能来调用这个方法了。所以在我以上的实现代码中是有一个继承于Observable的类的。

回头再看看那段注释（自己的烂翻译...有错请指出...）：我们不想让Observer在持有他自己的监听时在回调任意代码。抽取这段代码存储存储Observer需要同步的状态，但是并不通知这些Observer。任何潜在的竞争条件可能会导致的最坏情况是：

新添加的Observer将会错过一个正在进行的通知

最近被解除注册的Observer可能会错误的同步一个他不关心的玩意

这些东西说实话，我只是有一点点想法，并不能说的很清楚。我觉得是多线程情况下这段代码需要加上一个同步锁，不然可能会引发他注释里写的那两点糟糕的情况。我接触的多线程还是有点少的，所以这段我就先这么翻着，而且这对我们理解观察者模式的套路并没有非常大的影响。

分析完了Java中的观察者模式，接下来回到文章最前面提到的那个问题，RecyclerView中的ui更新到底是咋回事。

4、RecyclerView中的ui更新

其实要弄清楚这个首先得看Adapter，因为Adapter才是掌控数据集的那个。那么让我们来看一下RecyclerView.Adapter的nonotifyDataSetChanged()方法

public final void notifyDataSetChanged() {            mObservable.notifyChanged();        }复制代码

继续追踪这个源码，看看咋回事

static class AdapterDataObservable extends Observable
    
      {        public boolean hasObservers() {            return !mObservers.isEmpty();        }        public void notifyChanged() {            // 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();            }        }        //其余方法省略    }复制代码

可以看到notifyChanged()这个方法里就两行代码，经过上面的一番学习，我闭着眼睛也能猜到mObservers是一个Observer的集合，通过遍历的去调用onChanged，然后这个onChanged是回调。既然知道这一点，那么我们就需要在RecyclerView中找到Observer的具体实现类，不过在此之前我们找孩子之前得先找他爸~很简单，追踪onChanged()的源码，看看到底是谁的方法。

public static abstract class AdapterDataObserver {        public void onChanged() {            // Do nothing        }        public void onItemRangeChanged(int positionStart, int itemCount) {            // do nothing        }        public void onItemRangeChanged(int positionStart, int itemCount, Object payload) {            // fallback to onItemRangeChanged(positionStart, itemCount) if app            // does not override this method.            onItemRangeChanged(positionStart, itemCount);        }        public void onItemRangeInserted(int positionStart, int itemCount) {            // do nothing        }        public void onItemRangeRemoved(int positionStart, int itemCount) {            // do nothing        }        public void onItemRangeMoved(int fromPosition, int toPosition, int itemCount) {            // do nothing        }    }复制代码

找到了，都是空方法，你可能回说这还不是接口，没事，接口能做的抽象类也能做，我们只要找这个抽象类的孩子就行了。鸡贼的我果断ctrl+f输入了我的查找：

看一下他的源码：

private class RecyclerViewDataObserver extends AdapterDataObserver {        @Override        public void onChanged() {            assertNotInLayoutOrScroll(null);            if (mAdapter.hasStableIds()) {                // TODO Determine what actually changed.                // This is more important to implement now since this callback will disable all                // animations because we cannot rely on positions.                mState.mStructureChanged = true;                setDataSetChangedAfterLayout();            } else {                mState.mStructureChanged = true;                setDataSetChangedAfterLayout();            }            if (!mAdapterHelper.hasPendingUpdates()) {                requestLayout();            }        }		//省略部分代码...        void triggerUpdateProcessor() {            if (mPostUpdatesOnAnimation && mHasFixedSize && mIsAttached) {                ViewCompat.postOnAnimation(RecyclerView.this, mUpdateChildViewsRunnable);            } else {                mAdapterUpdateDuringMeasure = true;                requestLayout();            }        }    }复制代码

这里简单的看一下第一行代码是检查recyclerview，如果有错就会抛异常。之后第一个if，不看了，默认是false，那么就看第二个条件内的代码。第一个是存储一个状态，第二个是我们要看到的东西了，点进去看下源码：

private void setDataSetChangedAfterLayout() {        //省略部分代码        mDataSetHasChangedAfterLayout = true;        final int childCount = mChildHelper.getUnfilteredChildCount();        for (int i = 0; i < childCount; i++) {            final ViewHolder holder = getChildViewHolderInt(mChildHelper.getUnfilteredChildAt(i));            if (holder != null && !holder.shouldIgnore()) {                holder.addFlags(ViewHolder.FLAG_ADAPTER_POSITION_UNKNOWN);            }        }        mRecycler.setAdapterPositionsAsUnknown();    }复制代码

可以看到它会遍历ViewHolder，然后给holder添加flag:** FLAG_ADAPTER_POSITION_UNKNOWN**这个flag会让viewholder重新绑定到recyclerview上以确定自己的position，最后一个方法会让缓存的viewholder也打上上面提到的flag。

最后再回顾一下（如果有纰漏敬请指出，因为我这源码也没非常仔细的阅读）：

在想要更新RecyclerView的界面时，我们通常会先更新数据源（List之类的），然后调用Adapter的notifyDataSetChanged()方法

在RecyclerView内部notifyDataSetChanged()方法调用了mObservable.notifyChanged();而mObservable是一个被观察者。

在RecyclerView内部找到mObservable的真实类型，发现是RecyclerViewDataObserver，寻找notifyChanged()时会调用的onChanged()方法。

发现onChanged()方法最终会给viewholder设置flag，让他们重新绑定到RecyclerView上，在重新绑定的过程中无疑是会在onBindViewHolder里重新设置数据的，而数据源我们已经更新过了，新的数据就会被显示到界面上，以上就是这整个流程了。

5、最后的一点思考

说实话最近在写东西的时候经常用回调，因为一些工具类或者dialog、window之类的，在自己自定义的时候通常需要回调把点击事件传出来，不然感觉传view设置点击什么的感觉也挺麻烦的，不如我里面逻辑处理好，就把点击事件传出来就好了。但是写到后面我这又是用的MVP，activity里各种回调满天飞，不过怎么说呢，我自己写的，我看起来逻辑还是很清晰的。如果是后面来人接手呢？虽然我注释写的都很清晰了，但是他在阅读代码的时候不得不深入我的工具类或者dialog window里去看我这个回调到底干了什么，所以这种方便自己麻烦别人的东西，我现在在想到底是算好的代码风格还是差的，有点糊涂。

好了，也挺久没发文了，而且干了七天，相信大家都很累了，休息休息了，祝各位有一个好的周末。

最后安利一下这个主播，，安静听歌的感觉不错

参考资料：《Android源码设计模式》