Android 23种设计模式

前言

观察者模式是我们使用率比较高的一种模式了。这类文章网上也不少，通过本文我会让你彻底理解并记住什么事观察者模式。观察者模式使用率之所以比较高，是因为它在Android中能达到一个十分明显的解耦效果。让观察者和被观察者逻辑分开。使得UI层和业务逻辑清晰。更加利于我们拓展代码。

观察者模式定义

定义一个被观察者和多个观察者，每当被观察者变化，所有观察者都会得到通知。

理解重点

观察者模式核心就一个点，记住这个点你就能理解并记忆。要点：用一个list把观察者保存起来，并提供add和remove观察者，在被观察者变化的时候就遍历并调用list里观察者的方法。核心就是一个list遍历
下面我将用两个例子来具体说明观察者模式。例一是JDK自带的接口，例二是自己写观察者模式

例子一

先来一个订阅发布的例子。我们定义Android发布新的版本。Android为被观察者，当新版本发布的时候，我们通知所有观察者，新版本已发布。
1、定义观察者

public class PersonObserver implements Observer {
    static final String TAG = PersonObserver.class.getSimpleName();
    String name;

    public PersonObserver (String name) {
        this.name = name;
    }

    @Override
    public void update(Observable observable, Object o) {
        Log.d(TAG,name + " 接收到通知啦 "+ o);
    }
}

观察者就实现一个接口update方法，当被观察者发送消息的时候，我们就在update里接收
2、定义被观察者

public class AndroidObervable extends Observable {
    static final String TAG = AndroidObervable.class.getSimpleName();

    public void postNewVersion(String version) {
        setChanged(); // 标示内容发生改变
        notifyObservers(version);// 通知所有观察者
    }
}

被观察者继承自Observable，Observable里已经定义好了list,add,delete等方法，很好理解。
3、最后我们来看下怎么用的

        PersonObserver xiaoMing = new PersonObserver("xiaoMing");
        PersonObserver xiaoDong = new PersonObserver("xiaoDong");
        PersonObserver xiaoHong = new PersonObserver("xiaoHong");

       // 添加到集合里。
        AndroidObervable android = new AndroidObervable();
        android.addObserver(xiaoMing);
        android.addObserver(xiaoDong);
        android.addObserver(xiaoHong);
        // 通知
        android.postNewVersion("android O updated!");
        android.postNewVersion("android P updated!");

11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoMing 接收到通知啦 android O updated!
11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoDong 接收到通知啦 android O updated!
11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoHong 接收到通知啦 android O updated!
11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoMing 接收到通知啦 android P updated!
11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoDong 接收到通知啦 android P updated!
11-20 10:05:57.004 13623-13623/com.yink.designpattern.designpattern D/PersonObserver: xiaoHong 接收到通知啦 android P updated!

看输出都通知到了。观察者模式采用JDK原生的方式实现起来很简单。JDK都给我们封装好了。只管添加就好。这个例子适合我们先对观察者模式有一个大概理解，知道这就是观察者模式。

例二

接下来我们自己来实现观察者模式。我们以观察天气变化为例。
1、定义观察者

public abstract class WeatherOberver {

    public void typhoon() {

    }

    public abstract void sun();

    public abstract void rain();
}

这里和例一的差别是，我们用的抽象类，没用接口，他们思想都相似。这里我是为了区分事件，我们也可以用接口写，然后把各种天气用一个变量表示，这里就不详述了。
2、定义被观察者

public class WeatherObervable extends WeatherOberver{
    ArrayList<WeatherOberver> list = new ArrayList<>();

    public void add(WeatherOberver observerListener) {
        list.add(observerListener);
    }

    public void remove(WeatherOberver observerListener) {
        if (list.contains(observerListener)){
            list.remove(observerListener);
        }
    }

    @Override
    public void typhoon() {
        for (WeatherOberver observerListener : list) {
            observerListener.typhoon();
        }
    }

    @Override
    public void sun() {
        for (WeatherOberver observerListener : list) {
            observerListener.sun();
        }
    }

    @Override
    public void rain() {
        for (WeatherOberver observerListener : list) {
            observerListener.rain();
        }
    }
}

被观察者的实现也是简单粗暴。这里就体现了我们文章开始的时候说的观察者模式的核心了。一个list提供add,remove方法，把观察者放到集合里。需要通知的时候遍历通知即可。这下就好理解了吧。
3、最后看看调用。

private WeatherOberver xiaoDong = new WeatherOberver() {
        @Override
        public void typhoon() {
            Log.d("xiaoDong","吹台风，要放假了。哈哈！");
        }

        @Override
        public void sun() {

        }

        @Override
        public void rain() {
            Log.d("xiaoDong","下雨了，带伞");
        }
    };

    private WeatherOberver xiaoMing = new WeatherOberver() {

        @Override
        public void sun() {
            
        }

        @Override
        public void rain() {
            Log.d("xiaoMing","下雨了，带伞");
        }
    };

WeatherObervable weatherObervable = new WeatherObervable();
weatherObervable.add(xiaoMing);
weatherObervable.add(xiaoDong);

weatherObervable.rain();
weatherObervable.typhoon();

11-20 11:16:21.284 15580-15580/com.yink.designpattern.designpattern D/xiaoMing: 下雨了，带伞
11-20 11:16:21.284 15580-15580/com.yink.designpattern.designpattern D/xiaoDong: 下雨了，带伞
11-20 11:16:21.284 15580-15580/com.yink.designpattern.designpattern D/xiaoDong: 吹台风，要放假了。哈哈！

因为观察者我用的抽象类，除了天晴和下雨是必须继承的方法，刮台风可继承可不继承。所以我们可以更方便的观察我们需要观察的对象。小东在广东，吹台风他们公司就放假。所以他只关心哪天吹台风。小明比较讲究健康，关注下雨，下雨就带伞。

观察者模式小结

观察者模式就是将观察者和被观察者彻底隔离，实现解耦，只依赖于我们定义的抽象。观察者模式运用十分广泛，比如我们的ListView运用了观察者模式和Adapter是的Listview的可扩展性，灵活性非常强。还有比较出名的开源库EventBus也是用了观察者模式的思想实现解耦。

总结

优点：1、观察者和被观察者解耦 2、增强灵活性，解耦
缺点：由于java代码的顺序执行，要考虑被察者的执行效率，多个观察者需要及时响应就得考虑异步的问题了。
观察模式核心：一个list合集，提供add,remove方法，遍历观察者，就是一个list的遍历。