Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1227142
  • 博文数量: 114
  • 博客积分: 3526
  • 博客等级: 中校
  • 技术积分: 1825
  • 用 户 组: 普通用户
  • 注册时间: 2009-09-08 09:46
  • 认证徽章:
个人简介

记录总结自己的工作

文章分类

全部博文(114)

文章存档

2015年(19)

2014年(10)

2013年(6)

2012年(17)

2011年(24)

2010年(21)

2009年(17)

分类: Android平台

2015-09-21 16:51:03

    我们知道Rxjava对错误的处理很方便,就是当有错误出现的时候就会调用Subscriber的onError方法将错误分发出去,由Subscriber自己来处理错误。这种处理的错误有其优点,也有其缺点,就是每个Subscriber都要来定义如何处理错误,如果由100个Subscriber就要定义100遍,如何来统一地处理这些错误呢?这时我们就可以使用Error handling相关的操作符来集中统一地处理错误。

    一、Catch
    Catch类似于java 中的try/catch,当错误发生的时候,可以拦截对onError的调用,让Observable不会因为错误的产生而终止。在Rxjava中,将这个操作符实现为3个操作符,分别是:
    1、OnErrorReturn-当发生错误的时候,让Observable发射一个预先定义好的数据并正常地终止
    
    2、OnErrorResume-当发生错误的时候,由另外一个Observable来代替当前的Observable并继续发射数据
    
    3、OnExceptionResumeNext-类似于OnErrorResume,不同之处在于其会对onError抛出的数据类型做判断,如果是Exception,也会使用另外一个Observable代替
原Observable继续发射数据,否则会将错误分发给Subscriber
    
    下面使用OnErrorReturn和OnErrorResumeNext来分别处理两个Observable。

点击(此处)折叠或打开

  1. private Observable<String> onErrorReturnObserver() {
  2.         return createObserver().onErrorReturn(throwable -> "onErrorReturn");
  3.     }

  4.     private Observable<String> onErrorResumeNextObserver() {
  5.         return createObserver().onErrorResumeNext(Observable.just("7", "8", "9"));
  6.     }

  7.     private Observable<String> createObserver() {
  8.         return Observable.create(new Observable.OnSubscribe<String>() {
  9.             @Override
  10.             public void call(Subscriber<? super String> subscriber) {
  11.                 for (int i = 1; i <= 6; i++) {
  12.                     if (i < 3) {
  13.                         subscriber.onNext("onNext:" + i);
  14.                     } else {
  15.                         subscriber.onError(new Throwable("Throw error"));
  16.                     }
  17.                 }
  18.             }
  19.         });
  20.     }
    分别对其进行订阅

点击(此处)折叠或打开

  1. mLButton.setText("onErrorReturn");
  2.         mLButton.setOnClickListener(e -> onErrorReturnObserver().subscribe(new Subscriber<String>() {
  3.             @Override
  4.             public void onCompleted() {
  5.                 log("onErrorReturn-onCompleted\n");
  6.             }

  7.             @Override
  8.             public void onError(Throwable e) {
  9.                 log("onErrorReturn-onError:" + e.getMessage());
  10.             }

  11.             @Override
  12.             public void onNext(String s) {
  13.                 log("onErrorReturn-onNext:" + s);
  14.             }
  15.         }));
  16.         mRButton.setText("onErrorResume");
  17.         mRButton.setOnClickListener(e -> onErrorResumeNextObserver().subscribe(new Subscriber<String>() {
  18.             @Override
  19.             public void onCompleted() {
  20.                 log("onErrorResume-onCompleted\n");
  21.             }

  22.             @Override
  23.             public void onError(Throwable e) {
  24.                 log("onErrorResume-onError:" + e.getMessage());
  25.             }

  26.             @Override
  27.             public void onNext(String s) {
  28.                 log("onErrorResume-onNext:" + s);
  29.             }
  30.         }));
  31.     }
    运行结果如下。可以看到onErrorReturn在错误发生的时候继续发射了提前定义好的数据并正常结束Observable;
    而onErrorResume在错误发生后继续发射另外的数据7/8/9,然后正常结束了Observable。

    下面我们使用OnExceptionResumeNext操作符来处理两个Observable

点击(此处)折叠或打开

  1. private Observable<String> onExceptionResumeObserver(boolean isException) {
  2.         return createObserver(isException).onExceptionResumeNext(Observable.just("7", "8", "9"));
  3.     }


  4.     private Observable<String> createObserver(Boolean createExcetion) {
  5.         return Observable.create(new Observable.OnSubscribe<String>() {
  6.             @Override
  7.             public void call(Subscriber<? super String> subscriber) {
  8.                 for (int i = 1; i <= 6; i++) {
  9.                     if (i < 3) {
  10.                         subscriber.onNext("onNext:" + i);
  11.                     } else if (createExcetion) {
  12.                         subscriber.onError(new Exception("Exception"));
  13.                     } else {
  14.                         subscriber.onError(new Throwable("Throw error"));

  15.                     }
  16.                 }
  17.             }
  18.         });
  19.     }
    分别对其进行订阅

点击(此处)折叠或打开

  1. mLButton.setText("onException-true");
  2.         mLButton.setOnClickListener(e -> onExceptionResumeObserver(true).subscribe(new Subscriber<String>() {
  3.             @Override
  4.             public void onCompleted() {
  5.                 log("onException-true-onCompleted\n");
  6.             }

  7.             @Override
  8.             public void onError(Throwable e) {
  9.                 log("onException-true-onError:" + e.getMessage());
  10.             }

  11.             @Override
  12.             public void onNext(String s) {
  13.                 log("onException-true-onNext:" + s);
  14.             }
  15.         }));
  16.         mRButton.setText("onException-false");
  17.         mRButton.setOnClickListener(e -> onExceptionResumeObserver(false).subscribe(new Subscriber<String>() {
  18.             @Override
  19.             public void onCompleted() {
  20.                 log("onException-false-onCompleted\n");
  21.             }

  22.             @Override
  23.             public void onError(Throwable e) {
  24.                 log("onException-false-onError:" + e.getMessage());
  25.             }

  26.             @Override
  27.             public void onNext(String s) {
  28.                 log("onException-false-onNext:" + s);
  29.             }
  30.         }));
    运行结果如下。可以看到当发生错误时抛出的时Exception,则继续发射另外一个Observable的数据并正常结束;而抛出Throwable类型数据时,错误就分发到了Subscriber。


    二、Retry
    Retry操作符在发生错误的时候会重新进行订阅,而且可以重复多次,所以发射的数据可能会产生重复。如果重复指定次数还有错误的话就会将错误返回给观察者


    Rxjava还实现了RetryWhen操作符。当错误发生时,retryWhen会接收onError的throwable作为参数,并根据定义好的函数返回一个Observable,如果这个Observable发射一个数据,就会重新订阅。

    下面我们使用retry和retryWhen来处理两个Observable产生的错误,需要注意的是使用retryWhen的时候,因为每次重新订阅都会产生错误,所以作为参数的obserbvable会不断地发射数据,使用zipWith操作符可以限制重新订阅的次数,否则会无限制地重新订阅。

点击(此处)折叠或打开

  1. private Observable<Integer> retryObserver() {
  2.         return createObserver().retry(2);
  3.     }

  4.     private Observable<Integer> retryWhenObserver() {
  5.         return createObserver().retryWhen(observable -> observable.zipWith(Observable.just(1, 2, 3),
  6.                 (throwable, integer) -> throwable.getMessage() + integer)
  7.                 .flatMap(throwable -> {
  8.                     log(throwable);
  9.                     return Observable.timer(1, TimeUnit.SECONDS);
  10.                 }));

  11.     }

  12.     private Observable<Integer> createObserver() {
  13.         return Observable.create(new Observable.OnSubscribe<Integer>() {

  14.             @Override
  15.             public void call(Subscriber<? super Integer> subscriber) {
  16.                 log("subscribe");
  17.                 for (int i = 0; i < 3; i++) {
  18.                     if (i == 2) {
  19.                         subscriber.onError(new Exception("Exception-"));
  20.                     } else {
  21.                         subscriber.onNext(i);
  22.                     }
  23.                 }
  24.             }
  25.         });
  26.     }
    分别进行订阅

点击(此处)折叠或打开

  1. mLButton.setText("retry");
  2.         mLButton.setOnClickListener(e -> retryObserver().subscribe(new Subscriber<Integer>() {
  3.             @Override
  4.             public void onCompleted() {
  5.                 log("retry-onCompleted\n");
  6.             }

  7.             @Override
  8.             public void onError(Throwable e) {
  9.                 log("retry-onError:" + e.getMessage());
  10.             }

  11.             @Override
  12.             public void onNext(Integer s) {
  13.                 log("retry-onNext:" + s);
  14.             }
  15.         }));
  16.         mRButton.setText("retryWhen");
  17.         mRButton.setOnClickListener(e -> retryWhenObserver().subscribe(new Subscriber<Integer>() {
  18.             @Override
  19.             public void onCompleted() {
  20.                 log("retryWhen-onCompleted\n");
  21.             }

  22.             @Override
  23.             public void onError(Throwable e) {
  24.                 log("retryWhen-onError:" + e.getMessage());
  25.             }

  26.             @Override
  27.             public void onNext(Integer s) {
  28.                 log("retryWhen-onNext:" + s);
  29.             }
  30.         }));
  31.     }
    运行结果如下。在尝试了几次还是产生错误后,retry会将错误分发给观察者,而retryWhen会正常结束,并不会讲错误分发出去。


    关于错误的处理就到这里了,本文中的程序见:https://github.com/Chaoba/RxJavaDemo






阅读(3472) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册