android设计模式-观察者模式

也就是平时的按键监控其实不仅是接口的调用和回调，也是个观察者模式

//平常里的按钮事件监听例子
Button buttonA = (Button)findViewById(R.id.button1);
//注册观察者
buttonA.setOnClickListener(new OnClickListener()
{
　　//观察者实现
    @Override
    public void onClick(View view)
    {
        //这里可以知道要观察的对象的一举一动...
    }
});

//拆分后
buttonA                 ---->要观察的对象//要观察谁谁谁
setOnClickListener()    ---->观察者
new OnClickListener()   ---->观察者的实现//在实现里可以知道要观察的对象的一举一动

观察者模式定义：定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。比如按键监听。

两种方法：

使用JDK自带的，实际上也是和第二种方式一样的。

参考：https://www.jianshu.com/p/ec399a25e9d4

记住一个原则，把观察者用list的形式添加到被观察者里面，然后被观察者变化的时候去便利list，调用观察者的方法

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其实就可以理解成button的时候点击之后的onclick函数
    }
}

观察者就实现一个接口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，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();

这里做做理解：

实际上的观察者模式，用的是android最基本的语法规则罢了。把观察者放入到被观察者里面的list里面。由于被观察者继承的是观察者类。被观察者里面加入观察者对象，然后在被观察者里面用观察者的对象去调用函数（sun、rain），由于是观察者是抽象类，所以是需要其继承的子类去实现的。即会调用到子类当中的实现里面。就是button的onclick方法了

这里看起来没什么，但实际上，如果有很多人去观察了，那就比较方便了，直接通过add添加观察者即可，然后每个观察者关注的函数不一样的，当然可以全部通知：
weatherObervable.rain();
weatherObervable.typhoon();

xxxxxx

但是有些人关注下雨、有些人关注台风。那就只实现对应的抽象函数类OBservice即可了

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也是用了观察者模式的思想实现解耦。

作者：Yink_Liu
链接：https://www.jianshu.com/p/ec399a25e9d4
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。