rxjava的使用场景

1，简单的作为异步使用

Observable<Long> observable = Observable.just(1, 2)
        .subscribeOn(Schedulers.io()).map(new Func1<Integer, Long>() {
            @Override
            public Long call(Integer t) {
                try {
                    Thread.sleep(1000); //耗时的操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return (long) (t * 2);
            }
        });
observable.subscribe(new Subscriber<Long>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted");
    }
    @Override
    public void onError(Throwable e) {
        System.out.println("error" + e);
    }
    @Override
    public void onNext(Long result) {
        System.out.println("result = " + result);
    }
});
System.out.println("other...");

2，缓存处理多级缓存
操作符：concat

 //从数据库获取天气数据
        Observable<Weather> observableForGetWeatherFromDB = Observable.create(new Observable.OnSubscribe<Weather>() {
            @Override
            public void call(Subscriber<? super Weather> subscriber) {
                try {
                //数据库的操作
                    Weather weather = weatherDao.queryWeather(cityId);
                    subscriber.onNext(weather);
                    subscriber.onCompleted();
                } catch (SQLException e) {
                    throw Exceptions.propagate(e);
                }
            }
        });
        //判断网络是否可用的逻辑
if (!NetworkUtils.isNetworkConnected(context))
            return observableForGetWeatherFromDB;
//服务器获得
 observableForGetWeatherFromNetWork = observableForGetWeatherFromNetWork.doOnNext(weather -> Schedulers.io().createWorker().schedule(() -> {
            try {
            // 获得的数据插入数据库
             weatherDao.insertOrUpdateWeather(weather);
            } catch (SQLException e) {
                throw Exceptions.propagate(e);
            }
        }));
        //最终的整合代码
Observable.concat(observableForGetWeatherFromDB, observableForGetWeatherFromNetWork)
                .filter(weather -> weather != null && !TextUtils.isEmpty(weather.getCityId()))
                .distinct(weather -> weather.getWeatherLive().getTime())
                .takeUntil(weather -> System.currentTimeMillis() - weather.getWeatherLive().getTime() <= 60 * 60 * 1000);

其中操作符takeUntil的意思是：
Returns an Observable that emits items emitted by the source Observable, checks the specified predicate
for each item, and then completes if the condition is satisfied.

3，重试机制和异常处理
retry
可查看这篇文章

4，模拟发送发送验码

5，模拟用户登陆获取用户数据

6，使用combineLatest合并最近N个结点
例如：注册的时候所有输入信息（邮箱、密码、电话号码等）合法才点亮注册按钮。

      Observable<CharSequence> _emailChangeObservable = RxTextView.textChanges(_email).skip(1);


     Observable<CharSequence>   _numberChangeObservable = RxTextView.textChanges(_number).skip(1);

     Observable.combineLatest(_emailChangeObservable,
              _passwordChangeObservable,
              _numberChangeObservable,
              new Func3<CharSequence, CharSequence, CharSequence, Boolean>() {
                  @Override
                  public Boolean call(CharSequence newEmail,
                                      CharSequence newPassword,
                                      CharSequence newNumber) {

                      Log.d("xiayong",newEmail+" "+newPassword+" "+newNumber);
                      boolean emailValid = !isEmpty(newEmail) &&
                                           EMAIL_ADDRESS.matcher(newEmail).matches();
                      if (!emailValid) {
                          _email.setError("Invalid Email!");
                      }

                      boolean passValid = !isEmpty(newPassword) && newPassword.length() > 8;
                      if (!passValid) {
                          _password.setError("Invalid Password!");
                      }

                      boolean numValid = !isEmpty(newNumber);
                      if (numValid) {
                          int num = Integer.parseInt(newNumber.toString());
                          numValid = num > 0 && num <= 100;
                      }
                      if (!numValid) {
                          _number.setError("Invalid Number!");
                      }

                      return emailValid && passValid && numValid;

                  }
              })//
              .subscribe(new Observer<Boolean>() {
                  @Override
                  public void onCompleted() {
                      log.d("completed");
                  }

                  @Override
                  public void onError(Throwable e) {
                     log.d("Error");
                  }

                  @Override
                  public void onNext(Boolean formValid) {
                     _btnValidIndicator.setEnabled(formValid);  
                  }
              });

7，灵活转换线程的一种写法：
操作符Transformer+Observable.compose()；
在RXJava背后有一群聪明的人意识到了这是一个问题并且提供了解决方案：Transformer ，它和 Observable.compose() 一起使用。
创建一个调度器:

<T> Transformer<T, T> applySchedulers() {  
  return new Transformer<T, T>() {
    @Override
    public Observable<T, T> call(Observable<T> observable) {
      return observable.subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread());
    }
  };
}

可以进一步提供一个写一个类提供方法

public final class RxSchedulerUtils {
    /**
     * 由于在RxJava的使用过程中我们会频繁的调用subscribeOn()和observeOn(),通过Transformer结合
     * Observable.compose()达到复用这些代码的目的
     *
     * @return Transformer
     */
    public static <T> Observable.Transformer<T, T> normalSchedulersTransformer() {
        return observable -> observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

在项目中这样使用

 Subscription subscription = WeatherDataRepository.getWeather(context, cityId, weatherDao)              .compose(RxSchedulerUtils.normalSchedulersTransformer())
                .subscribe(weatherView::displayWeatherInformation, throwable -> {
                    Toast.makeText(context, throwable.getMessage(), Toast.LENGTH_LONG).show();
                });

其中：WeatherDataRepository.getWeather(context, cityId, weatherDao)是查询数据库的函数