RxJava Tips

本篇记录公司项目用的RxJava遇到的问题，本篇持续更新！

极力推荐 RxJava 入门到精通文章https://github.com/THEONE10211024/RxJavaSamples

欢迎加群讨论（158943444）：

RxJava RxAndroid Retrofit RxBus Dragger2 OkHttp MVP MVVM DataBinding

1、防止内存泄漏CompositeSubscription

使用CompositeSubscription可以防止RxJava带来的内存泄漏，因为用Rx流的地方比较多，所以直接把CompositeSubscription放到BasePresenter中，方便快捷

  public class BasePresenter implements Presenter{    
    public CompositeSubscription mCompositeSubscription;    
    public T view;    
    @Override    
    public void attachView(T t) {        
      mCompositeSubscription = new CompositeSubscription();        
      view = t;    
    }    
    @Override    
    public void detachView() {        
      mCompositeSubscription.unsubscribe();        
      mCompositeSubscription = null;        
      view = null;    
    }    
    public T getView(){        
      return view;    
    }
  }

然后在每一个Presenter中，只要把用到的RxJava流加到CompositeSubscription里面就可以了 mCompositeSubscription.add（RxJava流），这样不用担心RxJava带来的内存泄漏了。

2、线程切换compose的使用

使用RxJava的都知道，线程切换时多么的优雅！
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())

但是每次都要这样写也是挺烦的，用compose可以更优雅的切换线程.
在Rx流的最后用 compose(RxUtils.applyIOToMainThreadSchedulers())
这一句代码就可以切换了！

  public class RxUtils {    
    private staticObservable.TransformerioToMainThreadSchedulerTransformer;    
    private static Observable.Transformer newThreadToMainThreadSchedulerTransformer;    
    static {        
      ioToMainThreadSchedulerTransformer = createIOToMainThreadScheduler();        
      newThreadToMainThreadSchedulerTransformer = createNewThreadToMainThreadScheduler();
    }    
    private static  Observable.Transformer createIOToMainThreadScheduler() {        
      return tObservable -> tObservable.subscribeOn(Schedulers.io())    
              .unsubscribeOn(Schedulers.computation())               
              .observeOn(AndroidSchedulers.mainThread());    
    }    
    public static  Observable.Transformer applyIOToMainThreadSchedulers() {       
       return ioToMainThreadSchedulerTransformer;    
    }    
    private static  Observable.Transformer createNewThreadToMainThreadScheduler(){        
        return tObservable -> tObservable.subscribeOn(Schedulers.newThread())               
        .unsubscribeOn(Schedulers.computation())               
        .unsubscribeOn(Schedulers.io())               
        .observeOn(AndroidSchedulers.mainThread());    
    }    
    public static  Observable.Transformer applyNewThreadToMainThreadSchedulers(){        
      return newThreadToMainThreadSchedulerTransformer;   
   }
}

3、onErrorResumeNext的使用

情景：
当我们请求数据的时候，先请求网络上面的数据，没有的话请求硬盘上面的数据，并且想在同一个Rx流中处理这些操作.

方法：

使用onErrorResumeNext操作符，可以很好的完成上面的需求，在网络请求最后加上onErrorResumeNext(throwable -> getDisk())，这样整个Rx流就不会结束，然后会转到getDisk请求缓存数据的流中.

1、如果不用onErrorResumeNext，当网络出问题时候，请求网络数据的流就会执行OnError结束整个Rx流，然后我们必须在onError中在此发送请求缓存数据的Rx流，这样比较麻烦了。

2、使用concat操作符，使用concat也是要等到请求网络数据的Rx流执行到OnError的时候，才能在次执行请求缓存的Rx流，同样比较麻烦.

不知道有没有更好的方法，如果有，希望留言，谢谢！

4、filter的一个错误理解

由于没有很好的理解filter，以为filter过滤完所有数据（就是没有得到自己想要的数据）就会执行subscribe的onError，其实正确的是 会直接执行onComplete，然后整个流就结束了！
测试代码：

  Observable.create(new Observable.OnSubscribe() {    
    @Override    
    public void call(Subscriber subscriber) {        
      subscriber.onNext(null);        
      subscriber.onCompleted();    
      }
    })
    .filter(integer -> integer != null)        
    .subscribeOn(Schedulers.io())        
    .observeOn(AndroidSchedulers.mainThread())        
    .subscribe(new Subscriber() {            
        @Override            
        public void onCompleted() {                
          LogUtils.i("integer:");            
        }            
        @Override            
        public void onError(Throwable e) {                
          LogUtils.i("integer:" + e.getMessage());            
        }            
        @Override            
        public void onNext(Integer integer) {                
          LogUtils.i("integer:" + integer);            
        }        
    });