设计模式之---观察者模式简单分析

定义

观察者模式是一个使用率非常高的模式，他的一个重要作用就是用来解耦。它是一种一对多的依赖关系，当被观察者发生改变，所以的观察者都会收到通知

使用场景

有很多，如事件多级触发场景，关联行为场景，夸系统的消息交换场景，如消息队列，时间总线的处理机制

实例

/** * Created by zxa on 2017/3/21. * 观察者 */public class Visitor implements Observer{    public String name ;    @Override    public String toString() {        return "AdWall{" +                "name='" + name + '\'' +                '}';    }    public Visitor(String name) {        this.name = name;    }    @Override    public void update(Observable o, Object arg) {        Log.i("Visitor",o.toString()+"--"+name + "：广告墙 ，更新内容了，内容：" + arg);    }}/** * Created by zxa on 2017/3/21. * 这个类是被观察者的角色，相当于广告墙 */public class AdvWall extends Observable {    @Override    public String    toString() {        return  "AdvWall='" + boss;    }    public String boss = "boss说：";    public AdvWall() {    }    public void publicationNews(String content){        setChanged();        notifyObservers(content);    }}public class MainActivity extends AppCompatActivity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        AdvWall advWall = new AdvWall();        Visitor v_1 = new Visitor("visitor_1");        Visitor v_2 = new Visitor("visitor_2");        Visitor v_3 = new Visitor("visitor_3");        Visitor v_4 = new Visitor("visitor_4");        Visitor v_5 = new Visitor("visitor_5");        advWall.addObserver(v_1);        advWall.addObserver(v_2);        advWall.addObserver(v_3);        advWall.addObserver(v_4);        advWall.addObserver(v_5);        advWall.publicationNews("广告墙更新了，新的职位出来了，赶紧投简历-----手慢无");    }}

运行结果如下：
03-21 11:44:21.903 17004-17004/com.example.zxa.myapplication I/coder: hi,o：AdvWall{boss=’boss说：’}–visitor_1：广告墙 ，更新内容了，内容：广告墙更新了，新的职位出来了，赶紧投简历—–手慢无
03-21 11:44:21.903 17004-17004/com.example.zxa.myapplication I/coder: hi,o：AdvWall{boss=’boss说：’}–visitor_2：广告墙 ，更新内容了，内容：广告墙更新了，新的职位出来了，赶紧投简历—–手慢无
03-21 11:44:21.903 17004-17004/com.example.zxa.myapplication I/coder: hi,o：AdvWall{boss=’boss说：’}–visitor_3：广告墙 ，更新内容了，内容：广告墙更新了，新的职位出来了，赶紧投简历—–手慢无
03-21 11:44:21.903 17004-17004/com.example.zxa.myapplication I/coder: hi,o：AdvWall{boss=’boss说：’}–visitor_4：广告墙 ，更新内容了，内容：广告墙更新了，新的职位出来了，赶紧投简历—–手慢无
03-21 11:44:21.903 17004-17004/com.example.zxa.myapplication I/coder: hi,o：AdvWall{boss=’boss说：’}–visitor_5：广告墙 ，更新内容了，内容：广告墙更新了，新的职位出来了，赶紧投简历—–手慢无

源码分析

Observer是一个接口只有一个抽象方法void update(Observable o, Object arg);
下面的注释大体上说：
一个类想成为观察者希望被通知，就要实现

/** * A class can implement the <code>Observer</code> interface when it * wants to be informed of changes in observable objects. * * @author  Chris Warth * @see     java.util.Observable * @since   JDK1.0 */public interface Observer {    /**     * This method is called whenever the observed object is changed. An     * application calls an <tt>Observable</tt> object's     * <code>notifyObservers</code> method to have all the object's     * observers notified of the change.     *     * @param   o     the observable object.     * @param   arg   an argument passed to the <code>notifyObservers</code>     *                 method.     */    void update(Observable o, Object arg);}

Observable中保存了一个observers = new ArrayList<>();集合,用来保存观察者对象
setChanged clearChanged分别用来设置标志位

  /**     * Marks this <tt>Observable</tt> object as having been changed; the     * <tt>hasChanged</tt> method will now return <tt>true</tt>.     */    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 <tt>hasChanged</tt> method will now return <tt>false</tt>.     * This method is called automatically by the     * <code>notifyObservers</code> methods.     *     * @see     java.util.Observable#notifyObservers()     * @see     java.util.Observable#notifyObservers(java.lang.Object)     */    protected synchronized void clearChanged() {        changed = false;    }

notifyObservers用来通知各个观察者有新的内容更新，最主要通过changed这个标志位来标记。

   /**     * If this object has changed, as indicated by the     * <code>hasChanged</code> method, then notify all of its observers     * and then call the <code>clearChanged</code> method to indicate     * that this object has no longer changed.     * <p>     * Each observer has its <code>update</code> method called with two     * arguments: this observable object and the <code>arg</code> 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.         */        Observer[] arrLocal;        synchronized (this) {            /* We don't want the Observer doing callbacks into             * arbitrary Observables while holding its own Monitor.             * The code where we extract each Observable from             * the ArrayList 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 (!hasChanged())                return;            arrLocal = observers.toArray(new Observer[observers.size()]);            clearChanged();        }        for (int i = arrLocal.length-1; i>=0; i--)            arrLocal[i].update(this, arg);    }

Android源码中观察者

BaseAdapter中就有个被观察者如下：

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {    // 这里相当于上面的AdvWall类    private final DataSetObservable mDataSetObservable = new DataSetObservable();    public boolean hasStableIds() {        return false;    }    public void registerDataSetObserver(DataSetObserver observer) {        mDataSetObservable.registerObserver(observer);    }    public void unregisterDataSetObserver(DataSetObserver observer) {        mDataSetObservable.unregisterObserver(observer);    }

那观察者在哪里呢？ 我们看下

   @Override    public void setAdapter(ListAdapter adapter) {        if (mAdapter != null && mDataSetObserver != null) {           //这里解注册            mAdapter.unregisterDataSetObserver(mDataSetObserver);        }        resetList();        mRecycler.clear();        if (mHeaderViewInfos.size() > 0|| mFooterViewInfos.size() > 0) {            mAdapter = wrapHeaderListAdapterInternal(mHeaderViewInfos, mFooterViewInfos, adapter);        } else {            mAdapter = adapter;        }        mOldSelectedPosition = INVALID_POSITION;        mOldSelectedRowId = INVALID_ROW_ID;        // AbsListView#setAdapter will update choice mode states.        super.setAdapter(adapter);        if (mAdapter != null) {            mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();            mOldItemCount = mItemCount;            mItemCount = mAdapter.getCount();            checkFocus();            //这里new了一个观察者 并且注册            mDataSetObserver = new AdapterDataSetObserver();            mAdapter.registerDataSetObserver(mDataSetObserver);            --------}

下面看下AdapterDataSetObserver的实现

    class AdapterDataSetObserver extends AdapterView<ListAdapter>.AdapterDataSetObserver {        @Override        public void onChanged() {            super.onChanged();            if (mFastScroll != null) {                mFastScroll.onSectionsChanged();            }        }        @Override        public void onInvalidated() {            super.onInvalidated();            if (mFastScroll != null) {                mFastScroll.onSectionsChanged();            }        }    }

其中AdapterDataSetObserver中的onChanged()的实现如下

   class AdapterDataSetObserver extends DataSetObserver {        private Parcelable mInstanceState = null;        @Override        public void onChanged() {            mDataChanged = true;            mOldItemCount = mItemCount;            mItemCount = getAdapter().getCount();            // Detect the case where a cursor that was previously invalidated has            // been repopulated with new data.            if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null                    && mOldItemCount == 0 && mItemCount > 0) {                AdapterView.this.onRestoreInstanceState(mInstanceState);                mInstanceState = null;            } else {                rememberSyncState();            }            checkFocus();            requestLayout(); //这句话比较关键，是重新测量布局        }

综上所述，观察者在实际的开发中运用的非常的多，希望大家理解并熟练运用

注：本文参考 【Android源码设计模式】