设计模式之观察者模式

2017-11-03  本文已影响0人  菜小轩526

1 定义

定义对象之间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式的别名包括发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。观察者模式是一种对象行为型模式。

要点就是，观察者模式定义了一些列对象之间的一对多的关系，当一个对象改变状态，其他依赖者都会受到通知。
知晓定义之后，我们仍然需要了解他的应用场景：一个软件系统常常要求在某一个对象的状态发生变化的时候，某些其他的对象做出相应的改变。做到这一点的设计方案有很多，但是为了使系统能够易于复用，应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用，但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致，保证高度的协作。观察者模式是满足这一要求的各种设计方案中最重要的一种（此段摘抄，因为总结的真的好= =）。

2 类图

观察者模式类图.png

在任何时候我们都可以增加新的观察者，主题唯一依赖的是一个实现Observer接口的对象列表，当有新的类出现时，我们无需修改主题的代码，只需要将新类型实现观察者接口，然后注册为观察者即可。可以看到，修改具体主题或者观察者其中一方都不会影响另外一方，这种松耦合的设计更能应对变化，将对象之间的互相依赖降到最低，建立有弹性的OO系统。

3 简单实现

正好最近室友在玩彩票，我们就用彩票例子来做一个简单的实现。假定彩票庄家是被观察者，那么我们这些买彩票的玩家则为观察者，我们通过买彩票跟庄家绑定订阅关系，开奖的时候，庄家通知所有玩家中奖号码，我们则会知道自己有没有中奖。

//抽象观察者
interface UserObserver {
    void update(String winCode);
}
//具体观察者(彩票玩家)
class LotteryTicketUser implements UserObserver {
    private String code;
    private String name;

    public LotteryTicketUser(String code, String name) {
        this.code = code;
        this.name = name;
    }
    @Override
    public void update(String winCode) {
       System.out.println("我是" + name + (winCode.equals(code) ? "我中奖了！" : "我没中奖"));
    }
}
//抽象被观察者(庄家)
interface Banker { 
    //提供添加，删除，和通知观察者的方法
    void add(UserObserver observer) ;
    void remove(UserObserver observer) ;
    void notify(String winCode);
}
//具体被观察者(黑心庄家)
class BlackBanker implements Banker {
    private List<UserObserver> list = new ArrayList<>();

    @Override
    public void add(UserObserver observer) {
        list.add(observer);
    }

    @Override
    public void remove(UserObserver observer) {
        list.remove(observer);
    } 

    @Override
    public void notify(String winCode) {
        for (UserObserver observer : list) {
            observer.update(winCode);
        }
    }
}
//客户端
public class Main {
    public static void main(String[] args) {
        BlackBanker blackBanker = new BlackBanker();
        LotteryTicketUser user1 = new LotteryTicketUser("111","黑子");
        LotteryTicketUser user2 = new LotteryTicketUser("222","军哥");
        LotteryTicketUser user3 = new LotteryTicketUser("333","大将");
        blackBanker.add(user1);
        blackBanker.add(user2);
        blackBanker.add(user3);
        blackBanker.notify("444");
    }
}
//打印
我是黑子我没中奖
我是军哥我没中奖
我是大将我没中奖

中奖？不存在的。

4 两种实现方式

简单实现的只是一种实现方式，其实根据侧重的功能，观察者分为两种实现方式：

1.推模型

顾名思义，即被观察者通知观察者时，无论观察者是否需要，都会将全部或者部分信息推送至观察者，这些信息一般通过通知观察者的方法（例如上面的update）传递。

2.拉模型

观察者在接收通知的时候，可能不需要太多信息，而是在需要的时候自己去拉取，于是拉模型应运而生。这种实现方式，被观察者只向观察推送少量信息，一般来说是将自己的引用传递过去，以便观察者在需要的时候，获取自己的全部信息。

这里可以看到我们的简单实现只是一种推的方式，如果是拉模型的场景，可能就是比如有玩家需要知道庄家各种中奖信息，足彩，篮彩各种等等，那么这里我们可以通过update方法将庄家自身引用传递给玩家，玩家通过庄家提供一个获取所有中奖的方法来查看，关于具体代码就不做演示了。

5 案例分析

观察者模式可谓是应用极广，例如火了有一段时间的RxJava，EventBus这些消息队列、事件总线，又比如android中天天写的OnclickListener(一对一)，Adapter的notify，甚至是MVC，都跟观察者模式息息相关。太多的实例大家有兴趣都可以研究一下，接下来我选其中一个结合源码来探讨一番。

1.Adapter的notifyDataSetChanged()

日常的开发离不开setAdapter，同时使用Adapter的notifyDataSetChanged方法通知ListView数据刷新，先看BaseAdapter源码：

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中包含了一个观察者集合mDataSetObservable，同时提供了增加，删除，通知订阅者的方法，我们来看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();
            }
        }
    }

}

也就是遍历观察者们并调用他们的onChange方法。我们知道ListView和Adapter是通过setAdapter产生订阅关系的，接下来来看这个方法：

@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();
            //创建观察者并为adapter添加观察者
            mDataSetObserver = new AdapterDataSetObserver();
            mAdapter.registerDataSetObserver(mDataSetObserver);
       ...

        }

很明显在setAdapter中，新建了观察者并绑定了订阅关系。从前面的分析得知，notify的时候会调用观察者的onChange方法，我们来看看观察者的onChange：

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

啥也没有，我们点到supet.onChange()里面：

class AdapterDataSetObserver extends DataSetObserver {
        @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();
        }
    }

一大串，但是我们只需要关注这里的requestLayout()，他通知了ListView的重新布局。

小总结：
Adapter为被观察者，ListView为观察者（准确来说是ListView包含了一个观察者），两者通过setAdapter绑定发布-订阅的关系（Adapter添加了这个观察者）。当Adapter调用notifyDataSetChanged()时，他就会遍历他所添加的观察者们（此处即为ListView中的观察者），并调用他们的onChange()。而在onChange()中，会调用requestLayout()，从而使得ListView重新布局，达到数据刷新的目的。

要点总结

上一篇下一篇

猜你喜欢

热点阅读