用于改造响应代码处理的自定义 rx Func1

我是 rxjava 的新手，所以请不要严格......

我请求虱子下一个：

Observable<Login>login(String l, String p){
        return api.loginUser(l,p)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .flatMap(new Func1<Response<Login>, Observable<? extends Login>>() {
                    @Override
                    public Observable<? extends Login> call(Response<Login> r) {
                        switch (r.code()){
                            case 200:
                                requestOk(r);
                                break;
                            case 202:
                                //need to Repeat
                                login.timeout(2000,TimeUnit.Milliseconds);
                                break;
                            default:
                                //
                        }
                    }
                });
    }

Observable<Login> requestOk(final Response<Login> r){
            return Observable.create(new Observable.OnSubscribe<Login>(){
                @Override
                public void call(Subscriber<? super Login> subscriber) {
                    if (subscriber.isUnsubscribed()) return;
                    subscriber.onNext(r.body());
                    subscriber.onCompleted();
                }
            });
        }

工作正常。但是还会有很多其他请求，我需要检查请求代码以防重复。

所以我试图创建自定义 Func1 - 适合所有请求：

private <T>Func1<? super Response<T>, ? extends Observable<? extends T>> customFunc(final Observable<T> o) {
        return new Func1<Response<T>, Observable<? extends T>>() {
            @Override
            public Observable<? extends T> call(Response<T> r) {
                switch (r.code()){
                    case 200:
                        //
                        break;
                    case 202:
                        //need to Repeat
                        return o.timeout(2000,TimeUnit.Milliseconds);
                        break;
                    default:
                        //
                }
            };
        };
    }

我坚持将登录可观察中的当前可观察放入 customFunc 中。

我相信一定有其他更简单、更正确的方法来做到这一点。 会很高兴有任何帮助！

您可以使用Transformer为了创建通用状态代码验证器：

class StatusCodeVerifierTransformer<T> implements Observable.Transformer<Response<T>, T> {

    @Override
    public Observable<T> call(Observable<Response<T>> responseObservable) {
        return responseObservable.flatMap(new Func1<Response<T>, Observable<T>>() {
            @Override
            public Observable<T> call(Response<T> loginResponse) {
                switch (loginResponse.code()) {
                    case 200:
                        return Observable.just(loginResponse.body());
                    case 202:
                        //need to Repeat
                        return Observable.error(new Status202Exception());
                    default:
                        return Observable.error(new Exception("unknown error"));
                }
            }
        });

    }
}

该变压器将采取任何Observable of Response<T>并将其转换为Observable of T，根据您的策略发出错误。
然后将其与compose()操作员：

  Observable<Login> login(String l, String p) {
    return api.loginUser(l, p)
            .compose(new StatusCodeVerifierTransformer<>())
   }

现在你有一个Observable会发出onError根据您的状态代码处理您想要的异常。

现在，您可以像任何错误一样重试错误Observable with retry运算符，例如这样：

 api.loginUser(l, p)
            .compose(new StatusCodeVerifierTransformer<>())
            .retry(new Func2<Integer, Throwable, Boolean>() {
                @Override
                public Boolean call(Integer retryCount, Throwable throwable) {
                    return throwable instanceof Login202Exception && retryCount < MAX_RETRY;
                }
            })

BTW，一些评论：

requestOk - 你绝对不需要创建Observable要发出一次特定值，只需使用just()运算符，就像在StatusCodeVerifierTransformer例子。 （或者对于任何其他同步操作，您有很多运算符，例如fromCallable(), just(), from())
一般来说，create()不是一种安全的创建方法Observable不再了。