进行耗时任务
比如：在后台做一些网络操作、查询或者一些复杂计算的时候，
我们如果不用其他框架的话，
最常见做法即自己开一个子线程，
然后通过回调的形式获取到结果（如后台以结果为参数发送广播，前台回调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()方法；
简单看一下观察者设计模式的代码
- 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.一个方面的操作/处理依赖于另一个方面的状态变化；
（即观察者的操作依赖于被观察者的状态变化；
埋伏中的警察的操作依赖于小偷的状态变化，
球迷的操作依赖于球赛的状态变化）
- **如果在更改一个对象的时候，
需要同时连带改变其他的对象；**
- **当一个对象必须通知其他的对象，
但是你又希望这个对象和其他被通知的对象是松散耦合的；**
参考自 慕课网
