Rxjava解析笔记 | Rxjava概述 & 传统观察

2019-06-02 本文已影响5人凌川江雪

进行耗时任务

比如：在后台做一些网络操作、查询或者一些复杂计算的时候，
我们如果不用其他框架的话，
最常见做法即自己开一个子线程，
然后通过回调的形式获取到结果（如后台以结果为参数发送广播，前台回调onReceive()接收获取到结果）；

但是这样有一个问题，
随着业务逻辑越来越复杂，
项目会陷入回调中套回调的病区，
这对后期维护代码来说是一个很严重的问题；

而Rxjava的出现解决了以上的问题

Rxjava本质上是一个异步操作库；
它是一个能用非常简单的逻辑，去处理那些繁琐复杂任务 的
异步的操作事件库；
Rxjava在一定的程度上，
也能替代项目中非常多的Handler、AsyncTask等等；

关于Rxjava的设计模式——观察者模式

定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新；

在app开发中，如果有一个对象的状态/数据，是你非常要关心的，
同时你每个页面所有的UI都会跟这个对象绑定，
即当这个对象发生改变的时候，我们就需要通知所有的页面都去做UI改变；
以上所述其实便是一种观察者模式；
A对象对B对象的数据高度敏感，
当B对象变化的一瞬间，A对象要做出反应；
这时候A对象就是观察者，B对象就是被观察者；

观察者模式的情况，
就是众多的观察者，对被观察者的数据高度敏感，
被观察者变化之后观察者自身的一种反应,
它是一种一对多的关系，多个观察者对应一个被观察者；

观察者模式的UML类图
- Observerable（被观察者接口，interface）：
  - registerObserver()：将观察者注册到被观察者当中；即订阅方法；
  - removeObserver()：将观察者从被观察者中移出；取消订阅方法；
  - notifyObservers()：当我们被观察者状态改变的时候，这个方法就会被调用；
    而此方法内部又会调用观察者接口（Observer）的update()方法，
    去通知观察者（Observer）做出相应的处理改变；
- ConcreteObserverable（被观察者具体的实现，class）
  - 实现了Observerable（被观察者接口，interface）定义的三个方法；
  - 定义了List<Observer>，用于保存注册好的观察者；
    其泛型是Observer，是接口，而非具体的实现类，
    这样做的原因就是，
    为了让一个被观察者实例，
    可以对应着，可能会有的，
    多个实现了Observer（观察者）接口的观察者实现类，
    （一个被观察者实例可以对应多个观察者实现类实例）
    如此便可把观察者和被观察者通过List进行解耦；
    
    二来，泛型不指定具体的实现类，方便后续进行拓展，
    即只要把拓展的观察者实现类去实现观察接口便合格，
    由此可以实现各式各样的观察者；
- Observer（观察者接口）
  - 定义了update()方法；
    当我们被观察者状态改变的时候，notifyObservers()方法就会被调用；
    notifyObservers()内部则会调用本update()方法，
    去通知观察者（Observer）做出相应的处理改变；
- ConcreteObserver（观察者实现类）
  具体实现了Observer（观察者接口）的update()方法；

简单看一下Observer的代码

Observerable接口：

package com.example.jiajiemu.a11.observe;



/**
 * Created by Mjj on 2017/10/6.
 */

public interface Observerable {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObservers();
}

Observer接口：

package com.example.jiajiemu.a11.observe;

/**
 * Created by Mjj on 2017/10/6.
 */

public interface Observer {
    public void update(int edition,float cost);
}

ConcreteObserverable实现类：

package com.example.jiajiemu.a11.observe;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Mjj on 2017/10/6.
 */

public class ConcreteObserverable implements Observerable {

    private List<Observer> mObservers;
    private int edition;
    private float cost;

    public ConcreteObserverable() {
        mObservers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        mObservers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        int i = mObservers.indexOf(o);
        if(i >= 0)
            mObservers.remove(i);
    }

    @Override
    public void notifyObservers() {
        for(int i = 0; i < mObservers.size(); i++){
            Observer observer = mObservers.get(i);
            observer.update(edition, cost);
        }
    }

    public void setInfomation(int edition,float cost){
        this.edition = edition;
        this.cost = cost;
        //信息更新完毕，通知所有观察者
        notifyObservers();
    }

}

.
- notifyObservers()：
  可以看到方法中所写，遍历所有观察者，
  依次使每一个观察者调用update()方法进行数据更新
  （update()方法在ConcreteObserver中具体实现）：

    @Override
    public void notifyObservers() {
        for(int i = 0; i < mObservers.size(); i++){
            Observer observer = mObservers.get(i);
            observer.update(edition, cost);
        }
    }

ConcreteObserver实现类：

package com.example.jiajiemu.a11.observe;

/**
 * Created by Mjj on 2017/10/6.
 */

public class ConcreateObserver implements Observer {

    private String name;
    private int edition;
    private float cost;

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

    @Override
    public void update(int edition, float cost) {
        this.edition = edition;
        this.cost = cost;
        buy();
    }

    public void buy(){
        System.out.println(name+"购买了第"+edition+"期的杂志，花费了"+cost+"元。");
    }

}

.
- 主要实现，
  update()方法中添加的业务逻辑buy()方法，
  buy()方法是可以根据不同场景做相应的逻辑判断，数据更新；
  或者可以在update()方法中添加更多的业务逻辑；
Client客户端测试类：

package com.example.jiajiemu.a11.observe;

/**
 * Created by Mjj on 2017/10/6.
 */

public class Client {
    public static void main(String[] args) {
        //创建被观察者
        ConcreteObserverable concreteObserverable = new ConcreteObserverable();

        //创建三个不同的观察者
        Observer observerA = new ConcreateObserver("A");
        Observer observerB = new ConcreateObserver("B");
        Observer observerC = new ConcreateObserver("C");

        //将观察者注册到被观察者中
        concreteObserverable.registerObserver(observerA);
        concreteObserverable.registerObserver(observerB);
        concreteObserverable.registerObserver(observerC);

        //更新被观察者中的数据，当数据更新后，会自动通知所有已注册的观察者
        concreteObserverable.setInfomation(5, 12);
    }

}

.
- setInformation(),封装了一下notifyObservers():

@Override
    public void notifyObservers() {
        for(int i = 0; i < mObservers.size(); i++){
            Observer observer = mObservers.get(i);
            observer.update(edition, cost);
        }
    }

    public void setInfomation(int edition,float cost){
        this.edition = edition;
        this.cost = cost;
        //信息更新完毕，通知所有观察者
        notifyObservers();
    }

传统观察者模式的使用场景

1.一个方面的操作/处理依赖于另一个方面的状态变化；
（即观察者的操作依赖于被观察者的状态变化；
埋伏中的警察的操作依赖于小偷的状态变化，
球迷的操作依赖于球赛的状态变化）

如果在更改一个对象的时候，
需要同时连带改变其他的对象；
当一个对象必须通知其他的对象，
但是你又希望这个对象和其他被通知的对象是松散耦合的；

参考自慕课网