Retorfit RxJava Exception封装源码解读

作者博客

GitHub地址

如果喜欢可以给作者start

核心方法介绍

public final Observable<T> onErrorResumeNext(final Func1<Throwable, ? extends Observable<? extends T>> resumeFunction) {
    return lift(new OperatorOnErrorResumeNextViaFunction<T>(resumeFunction));
}

​ onErrorResumeNext:当接收到 上游得onError() 事件时，返回一个新的 Observable，并正常结束事件序列。

ServerResultFunc类

​ 主要用于处理服务器返回得数据。

private class ServerResultFunc<T> implements Func1<Result<T>, T> {
    @Override
    public T call(Result<T> httpResult) {
        //如果服务器返回得状态码不是200，则抛出异常，该异常会被下游onErrorResumeNext()方法捕获。
        if (httpResult.state != 200) {
            throw new ServerException(httpResult.state, httpResult.error);
        }
        //如果状态码是200，则正常执行流程，最后会回调Observer中得onNext()方法，并正常结束。这属于正常流程，不讨论。
        return httpResult.infos;
    }
}

HttpResultFunc类

​ 主要用于处理网络请求异常和ServerResultFunc中所抛出的异常。

private class HttpResultFunc<T> implements Func1<Throwable, Observable<T>> {
    @Override
    public Observable<T> call(Throwable throwable) {
        //处理网络请求异常
        //处理服务器返回数据异常
        //ExceptionEngine.handleException(throwable)方法会判断该异常属于哪种类型，再将该异常抛出，交给Observer对象onError方法处理。
        return Observable.error(ExceptionEngine.handleException(throwable));
    }
}

ExceptionEngine类

​ 主要用于处理HttpResultFunc类抛出的异常，该异常包括请求网络异常和服务器数据返回的数据异常，对这两类异常进行二次封装，统一格式，封装为ApiException对象，然后统一交由Observer对象的onError处理。

public class ExceptionEngine {

    public static ApiException handleException(Throwable e){
        ApiException ex;
        if (e instanceof HttpException){             //HTTP错误
            HttpException httpException = (HttpException) e;
            //统一封装为ApiException。
            ex = new ApiException(e, ERROR.HTTP_ERROR);
            return ex;
        } else if (e instanceof ServerException){    //服务器返回的错误
            ServerException resultException = (ServerException) e;
            //统一封装为ApiException
            ex = new ApiException(resultException, resultException.getCode());
            ex.setDisplayMessage(resultException.getMsg());
            return ex;
        } else if (e instanceof JsonParseException
                || e instanceof JSONException
                || e instanceof ParseException){、
            //统一封装为ApiException。
            ex = new ApiException(e, ERROR.PARSE_ERROR);
            ex.setDisplayMessage("解析错误");            //均视为解析错误
            return ex;
        }else if(e instanceof ConnectException){
            //统一封装为ApiException。
            ex = new ApiException(e, ERROR.NETWORD_ERROR);
            ex.setDisplayMessage("连接失败");  //均视为网络错误
            return ex;
        }else {
            //统一封装为ApiException。
            ex = new ApiException(e, ERROR.UNKNOWN);
            ex.setDisplayMessage("未知错误");          //未知错误
            return ex;
        }
    }
}

ApiException类

​ 将捕获的异常封装为统一的类型

public class ApiException extends Throwable {
    private int code;
    private String displayMessage;
    public  ApiException(Throwable throwable, int code) {
        super(throwable);
        this.code = code;
    }
    public void setDisplayMessage(String displayMessage) {
        this.displayMessage = displayMessage;
    }
    public String getDisplayMessage() {
        return displayMessage;
    }
    public int getCode() {
        return code;
    }
}

MyObserver类

​ 主要将接受到的Throwable 转为ApiException对象，方便统一处理。

public abstract class MyObserver<T> extends Subscriber<T> {
    @Override
    public void onError(Throwable e) {
            //将Throwable转为ApiException对象，统一交由Observer具体实现类处理。
            onError((ApiException)e);
    }
    /**
     * 错误回调
     */
    protected abstract void onError(ApiException ex);
}

使用

new Retrofit.Builder()
        .baseUrl(BASE_URL)
        .addConverterFactory(GsonConverterFactory.create())
        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
        .build()
        .create(Service.class)
        .readBaidu(username, password)
        .map(new ServerResultFunc<Login>())//处理服务器返回的数据
        .onErrorResumeNext(new HttpResultFunc<Login>())//将错误统一封装为ApiException
        .subscribeOn(Schedulers.io())
        .unsubscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new MyObserver<Login>() {
            @Override
            protected void onError(ApiException ex) {
            }
            @Override
            public void onCompleted() {
            }
            @Override
            public void onNext(Login login) {
            }
        });