设计模式（二）观察者模式（Head First）

于 2017-09-13 18:42:34 发布
阅读量304 收藏
点赞数 1
文章标签： 设计模式 观察者模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27942511/article/details/77967692
版权

说起设计模式，那就不得不提一下观察者模式，在android中，观察者模式使用频率还是很高的，比如我们经常用的onclickListener()就是采用的观察者模式实现的。那么观察者模式到底是什么呢，有什么作用，使用它会带来哪些便利？下面就来详细看一下这个伟大的模式。

观察者模式简介

定义

定义了对象之间一对多依赖，这样依赖，当一个对象改变状态时，它的所有依赖者都会受到通知并自动更新。
这里写图片描述

这里写图片描述

  • Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
  • ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
  • Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
  • ConcrereObserver：具体观察者，是实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

观察者模式代码实现

我们现在将观察者模式应用到WeatherData项目中来。于是有了下面这张类图：
这里写图片描述
这里写图片描述

主题接口

/**
 * Created by yzd on 2017/9/13 0013.
 * <p>
 * 主题、被观察者、发布者
 */

public interface Subject {

    /**
     * 注册观察者
     */
    void registerObserver(Observer observer);

    /**
     * 移除观察者
     */
    void removeObserver(Observer observer);


    /**
     * 通知观察者
     */
    void notifyObservers();
}

观察者接口

/**
 * Created by yzd on 2017/9/13 0013.
 * 观察者
 */

public interface Observer {
    void update(float temp, float humidity, float pressure);
}

公告牌统一接口

/**
 * Created by yzd on 2017/9/13 0013.
 */

public interface DisplayElement {
    /**
     * 展示
     */
    void display();
}

具体主题（被观察者、发布者）

/**
 * Created by yzd on 2017/9/13 0013.
 */

public class WeatherData implements Subject {

    private List<Observer> observers;

    private float temperature;//温度
    private float humidity;//湿度
    private float pressure;//气压

    public WeatherData() {
        observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        int index = observers.indexOf(observer);
        if (index >= 0) {
            observers.remove(index);
        }
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void measurementsChanged(){
        notifyObservers();
    }

    public void setMeasurements(float temperature, float humidity,
                                float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }

}

显示公告牌1


/**
 * Created by yzd on 2017/9/13 0013.
 */

public class Display1 implements Observer, DisplayElement {

    private Subject weatherData;

    private float temperature;//温度
    private float humidity;//湿度
    private float pressure;//气压

    public Display1(Subject weatherData) {
        this.weatherData = weatherData;
        this.weatherData.registerObserver(this);
    }

    @Override
    public void display() {
        Log.e("面板1", "温度:" + temperature + "湿度：" + humidity + "气压" + pressure);
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        this.temperature = temp;
        this.humidity = humidity;
        this.pressure = pressure;
        display();
    }
}

显示公告牌2

/**
 * Created by yzd on 2017/9/13 0013.
 */

public class Display2 implements Observer, DisplayElement {

    private Subject weatherData;

    private float temperature;//温度
    private float humidity;//湿度
    private float pressure;//气压

    public Display2(Subject weatherData) {
        this.weatherData = weatherData;
        this.weatherData.registerObserver(this);
    }

    @Override
    public void display() {
        Log.e("面板2", "温度:" + temperature + "湿度：" + humidity + "气压" + pressure);
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        this.temperature = temp;
        this.humidity = humidity;
        this.pressure = pressure;
        display();
    }
}

显示公告牌3

/**
 * Created by yzd on 2017/9/13 0013.
 */

public class Display3 implements Observer, DisplayElement {

    private Subject weatherData;

    private float temperature;//温度
    private float humidity;//湿度
    private float pressure;//气压

    public Display3(Subject weatherData) {
        this.weatherData = weatherData;
        this.weatherData.registerObserver(this);
    }

    @Override
    public void display() {
        Log.e("面板3", "温度:" + temperature + "湿度：" + humidity + "气压" + pressure);
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        this.temperature = temp;
        this.humidity = humidity;
        this.pressure = pressure;
        display();
    }
}

测试程序

在android程序中进行测试

 WeatherData weatherData = new WeatherData();

        Display1 display1 = new Display1(weatherData);
        Display2 display2 = new Display2(weatherData);
        Display3 display3 = new Display3(weatherData);

        weatherData.setMeasurements(80, 76, 20.9f);
        weatherData.setMeasurements(81, 74, 24.9f);
        weatherData.setMeasurements(70, 75, 20.5f);
        weatherData.setMeasurements(78, 79, 22.1f);

测试结果

E/面板1: 温度:80.0湿度：76.0气压20.9
E/面板2: 温度:80.0湿度：76.0气压20.9
E/面板3: 温度:80.0湿度：76.0气压20.9
E/面板1: 温度:81.0湿度：74.0气压24.9
E/面板2: 温度:81.0湿度：74.0气压24.9
E/面板3: 温度:81.0湿度：74.0气压24.9
E/面板1: 温度:70.0湿度：75.0气压20.5
E/面板2: 温度:70.0湿度：75.0气压20.5
E/面板3: 温度:70.0湿度：75.0气压20.5
E/面板1: 温度:78.0湿度：79.0气压22.1
E/面板2: 温度:78.0湿度：79.0气压22.1
E/面板3: 温度:78.0湿度：79.0气压22.1

当数据发生改变时，这3个面板都会接受到改变后的数据。

优缺点

优点

解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变换都不会影响另一边的变换。

缺点

在应用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。

Android中的观察者模式

android源码中也有很多使用了观察者模式，比如OnClickListener、ContentObserver、android.database.Observable等；还有组件通讯库RxJava、RxAndroid、EventBus；

我们来看看BaseAdaper的部分源码：

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {

    //数据集观察者
    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);
    }

    /**
     * 当数据集变化时，通知所有观察者
     */
    public void notifyDataSetChanged() {
        mDataSetObservable.notifyChanged();
    }

很明显BaseAdapter用的是观察者模式，BaseAdapter是具体被观察者，接下来看看mDataSetObservable.notifyChanged()：

public class DataSetObservable extends Observable<DataSetObserver> {
    public void notifyChanged() {
        synchronized(mObservers) {
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onChanged();
            }
        }
    }

我们看到了mObservers，这就是观察者的集合，这些观察者是在ListView通过setAdaper()设置Adaper时产生的：

@Override
    public void setAdapter(ListAdapter adapter) {
        if (mAdapter != null && mDataSetObserver != null) {
            mAdapter.unregisterDataSetObserver(mDataSetObserver);
        }
        ...
        super.setAdapter(adapter);

        if (mAdapter != null) {
            mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
            mOldItemCount = mItemCount;
            mItemCount = mAdapter.getCount();
            checkFocus();
            //创建数据观察者
            mDataSetObserver = new AdapterDataSetObserver();
            //注册观察者
            mAdapter.registerDataSetObserver(mDataSetObserver);

            ...
        }

接下来看看观察者AdapterDataSetObserver中处理了什么：

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

        @Override
        public void onInvalidated() {
            super.onInvalidated();
            if (mFastScroller != null) {
                mFastScroller.onSectionsChanged();
            }
        }
    }

从上面的代码看不出什么，再看看AdapterDataSetObserver的父类AdapterView的AdapterDataSetObserver：

class AdapterDataSetObserver extends DataSetObserver {
        private Parcelable mInstanceState = null;
        @Override
        public void onChanged() {
            mDataChanged = true;
            mOldItemCount = mItemCount;
            mItemCount = getAdapter().getCount();
            if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null
                    && mOldItemCount == 0 && mItemCount > 0) {
                AdapterView.this.onRestoreInstanceState(mInstanceState);
                mInstanceState = null;
            } else {
                rememberSyncState();
            }
            checkFocus();
            //重新布局
            requestLayout();
        }

        ...

        public void clearSavedState() {
            mInstanceState = null;
        }
    }

我们看到在onChanged()方法中调用了requestLayout()方法来重新进行布局。好了，看到这里我们都明白了，当ListView的数据发生变化时，我们调用Adapter的notifyDataSetChanged()方法，这个方法又会调用观察者们（AdapterDataSetObserver）的onChanged()方法，onChanged()方法又会调用requestLayout()方法来重新进行布局。

下一篇会对EventBus的源码进行解析。

NicholasYzd
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值