RxJava学习(六)

今天来看看RxJava中关于错误的处理

在RxJava中我们可以很方便地处理异常，只要加上onError即可
不过，如果异常发生在操作符内部，比如flatMap，那我们怎么把这个异常传递给onError呢。

这里先介绍两个概念

Checked异常和Unchecked异常

• Checked异常必须被显式地捕获或者传递，而unchecked异常则可以不必捕获或抛出。
• Checked异常继承java.lang.Exception类。Unchecked异常继承自java.lang.RuntimeException类。

Unchecked异常

一般情况下，unchecked异常会自动传递给onError。例如以下代码可以弹出“Error“

   rx.Observable.just("hello").map(new Func1<String, String>() {
            @Override
            public String call(String s) {
                throw new RuntimeException();
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {

            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                Toast.makeText(MainActivity.this, "error", Toast.LENGTH_SHORT).show();
            }
        });
    }

Checked异常

尽管RxJava有自己的异常处理机制，不过Checked异常还是必须由你的代码来处理，也就是说，还是要自己加try-catch。
假如有下面的方法

 public String transform() throws ArithmeticException{
        return 1/0+"";
    }

我们处理是就要捕获了

   Observable.just("hello").map(new Func1<String, String>() {
            @Override
            public String call(String s) {
                try {
                    return transform();
                } catch (ArithmeticException e) {
                    //将checked
                    throw Exceptions.propagate(e);
                }
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "onCompleted: ");
            }
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: "+3);
                Toast.makeText(MainActivity.this, "e:" + e, Toast.LENGTH_SHORT).show();
            }
            @Override
            public void onNext(String s) {
                Log.d(TAG, "onNext: "+s);

            }
        });

因为OnError只能接受UnCheckd异常，我们怎么做呢，在这里使用了Exceptions.propagate(e)，这个方法的作用就是把Checked异常转化为UnChecked异常。

而对于像flatMap这样返回Observable对象的操作，可以直接返回Observable.error()

  rx.Observable.just("hello").flatMap(new Func1<String, rx.Observable<?>>() {
            @Override
            public rx.Observable<?> call(String s) {
                try {
                    return rx.Observable.just(transform());
                } catch (IOException e) {
                    return rx.Observable.error(e);
                }
            }
        }).subscribe(new Action1<Object>() {
            @Override
            public void call(Object o) {

            }
        });

异常的屏蔽

很多RxJava初学者都犯了一个错误，过度地使用onError，其实onError应该在数据无法继续处理下去时才使用。例如，在使用Retrofit 1的时候，响应的状态码为非200的结果调用onError，这样，我们在处理非200的响应结果时就会变得十分麻烦。这个问题在Retrofit 2已经解决了.

也就是说，通常，你可以在发生错误的时候给onNext一个错误的标识，然后直接在onNext中处理问题，而不是跳过代码进入onError，这样还是可以不中断你的数据流，继续运行你的代码。

如何屏蔽异常而不把异常抛给onError，以下有两种选择：

• onErrorReturn()，在遇到错误时发射一个特定的数据
• onErrorResumeNext()，在遇到错误时发射一个数据序列

  rx.Observable.just("hello").map(new Func1<String, Object>() {
            @Override
            public Object call(String s) {
//                dangerousOperation  危险的操作
                return null;
            }
        }).onErrorReturn(new Func1<Throwable, Object>() {
            @Override//当触发异常时，不会执行OnErro,会执行此方法，打印出onError
            public Object call(Throwable throwable) {
                System.out.println("==========onError");
                return null;
            }
        });

   rx.Observable.just("hello").map(new Func1<String, Object>() {
            @Override
            public Object call(String s) {
//                dangerousOperation  危险的操作
                return null;
            }
        }).onErrorResumeNext(new Func1<Throwable, Observable<?>>() {
            @Override
            public Observable<?> call(Throwable throwable) {
                return null;
            }
        });