Android的设计模式-观察者模式

前言

Android的设计模式系列文章介绍，欢迎关注，持续更新中：

Android的设计模式-设计模式的六大原则
一句话总结23种设计模式则
创建型模式：
Android的设计模式-单例模式
Android的设计模式-建造者模式
Android的设计模式-工厂方法模式
Android的设计模式-简单工厂模式
Android的设计模式-抽象工厂模式
Android的设计模式-原型模式
行为型模式：
Android的设计模式-策略模式
Android的设计模式-状态模式
Android的设计模式-责任链模式
Android的设计模式-观察者模式
Android的设计模式-模板方法模式
Android的设计模式-迭代器模式
Android的设计模式-备忘录模式
Android的设计模式-访问者模式
Android的设计模式-中介者模式
Android的设计模式-解释器模式
Android的设计模式-命令模式
结构型模式：
Android的设计模式-代理模式
Android的设计模式-组合模式
Android的设计模式-适配器模式
Android的设计模式-装饰者模式
Android的设计模式-享元模式
Android的设计模式-外观模式
Android的设计模式-桥接模式

1.定义

定义对象间的一种一个对多的依赖关系，当一个对象的状态发送改变时，所以依赖于它的对象都得到通知并被自动更新。

2.介绍

• 观察者属于行为型模式。
• 观察者模式又被称作发布/订阅模式。
• 观察者模式主要用来解耦，将被观察者和观察者解耦，让他们之间没有没有依赖或者依赖关系很小。

3.UML类图

观察者模式UML类图 .jpg

角色说明：

• Subject（抽象主题）：又叫抽象被观察者，把所有观察者对象的引用保存到一个集合里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。
• ConcreteSubject（具体主题）：又叫具体被观察者，将有关状态存入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知。
• Observer (抽象观察者):为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
• ConcrereObserver（具体观察者）：实现抽象观察者定义的更新接口，当得到主题更改通知时更新自身的状态。

4.实现

继续以送快递为例，快递员有时只是把快递拉到楼下，然后就通知收件人下楼去取快递。

4.1 创建抽象观察者

定义一个接到通知的更新方法，即收件人收到通知后的反应：

    public interface Observer {//抽象观察者
        public void update(String message);//更新方法
    }

4.2 创建具体观察者

实现抽象观察者中的方法，这里创建两个类，一个男孩类和一个女孩类，定义他们收到通知后的反应：

    public class Boy implements Observer {

        private String name;//名字
        public Boy(String name) {
            this.name = name;
        }
        @Override
        public void update(String message) {//男孩的具体反应
            System.out.println(name + ",收到了信息:" + message+"屁颠颠的去取快递.");
        }
    }

    public class Girl implements Observer {

        private String name;//名字
        public Girl(String name) {
            this.name = name;
        }
        @Override
        public void update(String message) {//女孩的具体反应
            System.out.println(name + ",收到了信息:" + message+"让男朋友去取快递~");
        }
    }

4.3 创建抽象主题

即抽象被观察者，定义添加，删除，通知等方法：

    public interface  Observable {//抽象被观察者
         void add(Observer observer);//添加观察者
 
         void remove(Observer observer);//删除观察者
    
         void notify(String message);//通知观察者
    }

4.4 创建具体主题

即具体被观察者，也就是快递员，派送快递时根据快递信息来通知收件人让其来取件：

    public class Postman implements  Observable{//快递员
        
        private List<Observer> personList = new ArrayList<Observer>();//保存收件人（观察者）的信息
        @Override
        public void add(Observer observer) {//添加收件人
            personList.add(observer);
        }

        @Override
        public void remove(Observer observer) {//移除收件人
            personList.remove(observer);

        }

        @Override
        public void notify(String message) {//逐一通知收件人（观察者）
            for (Observer observer : personList) {
                observer.update(message);
            }
        }
    }

4.5 客户端测试

    public void test(){
        Observable postman=new Postman();
        
        Observer boy1=new Boy("路飞");
        Observer boy2=new Boy("乔巴");
        Observer girl1=new Girl("娜美");

        postman.add(boy1);
        postman.add(boy2);
        postman.add(girl1);
        
        postman.notify("快递到了,请下楼领取.");
    }

输出结果：

路飞,收到了信息:快递到了,请下楼领取.屁颠颠的去取快递.
乔巴,收到了信息:快递到了,请下楼领取.屁颠颠的去取快递.
娜美,收到了信息:快递到了,请下楼领取.让男朋友去取快递~

4.6 说明：

实际上，JDK内部也内置了Observable（抽象被观察者），Observer（抽象观察者）这两个类，我们也可以直接拿来用，其代码如下：

public interface Observer {//（抽象观察者
    //只定义了一个update方法
    void update(Observable o, Object arg);
}

public class Observable {//抽象被观察者
    private boolean changed = false;//定义改变状态，默认为false
    private final ArrayList<Observer> observers;//定义一个观察者list

    public Observable() {//构造函数，初始化一个观察者list来保存观察者
        observers = new ArrayList<>();
    }
    //添加观察者，带同步字段的，所以是线程安全的
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!observers.contains(o)) {
            observers.add(o);
        }
    }

    //删除观察者
    public synchronized void deleteObserver(Observer o) {
        observers.remove(o);
    }

    //通知所以观察者，无参数
    public void notifyObservers() {
        notifyObservers(null);
    }

     //通知所有观察者，带参数
    public void notifyObservers(Object arg) {

        Observer[] arrLocal;
        //加synchronized字段，保证多线程下操作没有问题
        synchronized (this) {
            if (!hasChanged())//这里做了是否发生改变的判断，是为了防止出现无意义的更新
                return;

            arrLocal = observers.toArray(new Observer[observers.size()]);//ArrayList转换成一个临时的数组，这样就防止了通知，添加，移除同时发生可能导致的异常
            clearChanged();///清除改变状态，设置为false
        }
        //遍历逐一通知
        for (int i = arrLocal.length-1; i>=0; i--)
            arrLocal[i].update(this, arg);
    }

    //清楚所有观察者
    public synchronized void deleteObservers() {
        observers.clear();
    }

    //设置被观察者为改变状态，设置为true
    protected synchronized void setChanged() {
        changed = true;
    }

    //清除改变状态，设置为false
    protected synchronized void clearChanged() {
        changed = false;
    }

    //返回当前的改变状态
    public synchronized boolean hasChanged() {
        return changed;
    }

    //观察者数量
    public synchronized int countObservers() {
        return observers.size();
    }
}

5. 应用场景

• 当一个对象的改变需要通知其它对象改变时，而且它不知道具体有多少个对象有待改变时。
• 当一个对象必须通知其它对象，而它又不能假定其它对象是谁
• 跨系统的消息交换场景，如消息队列、事件总线的处理机制。

6. 优点

• 解除观察者与主题之间的耦合。让耦合的双方都依赖于抽象，而不是依赖具体。从而使得各自的变化都不会影响另一边的变化。
• 易于扩展，对同一主题新增观察者时无需修改原有代码。

7. 缺点

• 依赖关系并未完全解除，抽象主题仍然依赖抽象观察者。
• 使用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。
• 可能会引起多余的数据通知。

8. Android中的源码分析

8.1 控件中Listener监听方式

Android中我们遇到的最常用的观察者模式就是各种控件的监听,如下:

        Button button = (Button) findViewById(R.id.button);
        //注册观察者
        button.setOnClickListener(new View.OnClickListener() {
            //观察者实现
            @Override
            public void onClick(View arg0) {
                Log.d("test", "Click button ");
            }
        });

上面代码中，button就是具体的主题，也就是被观察者；new出来的View.OnClickListenerd对象就是具体的观察者;OnClickListener实际上就是个接口，也就是抽象观察者；通过setOnClickListener把观察者注册到被观察者中。

一旦button捕获的点击事件，即状态发生变化的时候，就会通过回调注册的OnClickListener观察者的onClick方法会来通知观察者，Button状态发生变化。。

相关源码分析：

    public interface OnClickListener {//抽象观察者

        void onClick(View v);//只有onClick这个方法
    }

    //注册观察者
    public void setOnClickListener(@Nullable View.OnClickListener l) {
        if (!isClickable()) {
            setClickable(true);//设置为可点击
        }
        getListenerInfo().mOnClickListener = l;//把传入的 OnClickListener 对象赋值给了 getListenerInfo().mOnClickListener,即mListenerInfo的mOnClickListener持有OnClickListener对象的引用
    }

    ListenerInfo getListenerInfo() {//返回ListenerInfo对象,这里是一个单例模式
        if (mListenerInfo != null) {
            return mListenerInfo;
        }
        mListenerInfo = new ListenerInfo();
        return mListenerInfo;
    }

    public boolean performClick() {//执行点击事件
        final boolean result;
        final ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnClickListener != null) {
            playSoundEffect(SoundEffectConstants.CLICK);
            li.mOnClickListener.onClick(this);//执行onClick方法,li.mOnClickListener即OnClickListener对象
            result = true;
        } else {
            result = false;
        }

        sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
        return result;
    }

8.2 Adapter的notifyDataSetChanged()方法

当我们使用ListView时，需要更新数据时我们就会调用Adapter的notifyDataSetChanged()方法，那么我们来看看notifyDataSetChanged()的实现原理，这个方法是定义在BaseAdaper中，具体代码如下：

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {
     //数据集被观察者
    private final DataSetObservable mDataSetObservable = new DataSetObservable();

    //注册观察者
    public void registerDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.registerObserver(observer);
    }
    //注销观察者
    public void unregisterDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.unregisterObserver(observer);
    }
    //数据集改变时，通知所有观察者
    public void notifyDataSetChanged() {
        mDataSetObservable.notifyChanged();
    }
}
    //其他代码略

由上面的代码可以看出BaseAdapter实际上就是使用了观察者模式，BaseAdapter就是具体的被观察者。接下来看看 mDataSetObservable.notifyChanged()的实现：

//数据集被观察者
public class DataSetObservable extends Observable<DataSetObserver> {
   
    public void notifyChanged() {
        synchronized(mObservers) {
            //遍历所有观察者，并调用他们的onChanged()方法
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onChanged();
            }
        }
    }

    //其他代码略
}

现在我们看到了有观察者的影子，那么这些观察者是从哪里来的呢？实际上这些观察者是在ListView通过setAdaper()设置Adaper时产生的：

public class ListView extends AbsListView {
    //其他代码略
    
    public void setAdapter(ListAdapter adapter) {
        //如果已存在Adapter，先注销该Adapter的观察者
        if (mAdapter != null && mDataSetObserver != null) {
            mAdapter.unregisterDataSetObserver(mDataSetObserver);
        }
        
        //其他代码略
        
        super.setAdapter(adapter);

        if (mAdapter != null) {
            mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
            mOldItemCount = mItemCount;
            mItemCount = mAdapter.getCount();//获取Adapter中的数据的数量
            checkFocus();

            mDataSetObserver = new AdapterDataSetObserver();//创建一个数据集观察者
            mAdapter.registerDataSetObserver(mDataSetObserver);//注册观察者

           //其他代码略
        } 
    }
}

从上面的代码可以看到，观察者有了，那么这个观察者主要是干什么的呢？

class AdapterDataSetObserver extends AdapterView<ListAdapter>.AdapterDataSetObserver {
        @Override
        public void onChanged() {
            super.onChanged();//调用父类的onChanged()方法
            if (mFastScroller != null) {
                mFastScroller.onSectionsChanged();
            }
        }

       //其他代码略
    }

AdapterDataSetObserver类中的onChanged()方法没看出啥，继续看他父类的onChanged()方法：

class AdapterDataSetObserver extends DataSetObserver {
        private Parcelable mInstanceState = null;
        //观察者的核心实现
        @Override
        public void onChanged() {
            mDataChanged = true;
            mOldItemCount = mItemCount;
            mItemCount = getAdapter().getCount();//获取Adapter中的数据的数量
            if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null
                    && mOldItemCount == 0 && mItemCount > 0) {
                AdapterView.this.onRestoreInstanceState(mInstanceState);
                mInstanceState = null;
            } else {
                rememberSyncState();
            }
            checkFocus();
            //重新布局
            requestLayout();
        }

       //其他代码略
    }

最终就是在AdapterDataSetObserver这个类里面的onChanged()方法中实现了布局的更新。

简单总结：

• 当ListView的数据发生变化时，我们调用Adapter的notifyDataSetChanged()方法，这个方法又会调用所有观察者（AdapterDataSetObserver）的onChanged()方法，onChanged()方法又会调用requestLayout()方法来重新进行布局。

8.3 BroadcastReceiver

BroadcastReceiver作为Android的四大组件之一,实际上也是一个典型的观察者模式.通过sendBroadcast发送广播时,只有注册了相应的IntentFilter的BroadcastReceiver对象才会收到这个广播信息,其onReceive方法才会被调起.BroadcastReceiver的代码比较复杂,这里就不展开了.先挖个坑,后面也会出BroadcastReceiver的相关源码分析.

8.4 其他

另外,一些著名的第三方事件总线库,比如RxJava、RxAndroid、EventBus、otto等等,也是使用了观察者模式.有兴趣的可以去看下他们的源码.

相关文章阅读
Android的设计模式-设计模式的六大原则
一句话总结23种设计模式则
创建型模式：
Android的设计模式-单例模式
Android的设计模式-建造者模式
Android的设计模式-工厂方法模式
Android的设计模式-简单工厂模式
Android的设计模式-抽象工厂模式
Android的设计模式-原型模式
行为型模式：
Android的设计模式-策略模式
Android的设计模式-状态模式
Android的设计模式-责任链模式
Android的设计模式-观察者模式
Android的设计模式-模板方法模式
Android的设计模式-迭代器模式
Android的设计模式-备忘录模式
Android的设计模式-访问者模式
Android的设计模式-中介者模式
Android的设计模式-解释器模式
Android的设计模式-命令模式
结构型模式：
Android的设计模式-代理模式
Android的设计模式-组合模式
Android的设计模式-适配器模式
Android的设计模式-装饰者模式
Android的设计模式-享元模式
Android的设计模式-外观模式
Android的设计模式-桥接模式