使用RxJava和Retrofit进行N次连续api调用

Question

我有一个文件列表，我想从Android设备上传到后端。 由于内存限制，我想在第一次完成之后进行第二次API调用，在第二次完成之后进行第三次API调用，依此类推。

我写了类似的东西

private Observable<Integer> uploadFiles(List<File> files) {
        return Observable.create(subscriber -> {
            for (int i = 0, size = files.size(); i < size; i++) {
                UploadModel uploadModel = new UploadModel(files.get(0));
                int uploadResult = retrofitApi.uploadSynchronously(uploadModel);
                subscriber.onNext(uploadResult);
            }
            subscriber.onCompleted();
        }).subscribeOn(Schedulers.newThread());
    }

但是我觉得这可能违背了Rx的精神，而且说的是如果你使用Observable.create，你可能做错了......这是一种合理的方法吗？ 使用Retrofit的RxJava集成是否有更好的方法来实现这一目标？

Answer 1

天真地，我会这样做（但它不起作用，见下文）：

return Observable.from(files).concatMap(file -> retrofitApi.upload(uploadModel));

现在的问题是，没有办法告诉改造仅使用一个线程进行这些调用。

但是， reduce将一个函数调用的结果传递给下一个，以及原始observable的下一个发出值。 这可行，但传递的函数reduce需要同步。 不好。

另一种方法是递归地修改observable：

void getNextFile(int i) {
    return retrofit.upload(i).
        onNext(result -> getNextFile(i + 1));
}

大致。 但我不知道如何清理它以使其更具可读性。

我认为最干净的是：

Observable.from(files).map(file -> retrofitApi.uploadSynchronously(new UploadModel(file)));

Answer 2

RxJava的原生代码会发出Observable.from(...)所有项目，就像并行一样。 这是将其视为平行排放的最佳方式。 然而，有些情况需要真正的后续执行整个链。 我来到以下解决方案，可能不是最好的解决方案，但工作。

import rx.Observable;
import rx.Subscriber;

import java.util.Iterator;
import java.util.function.Function;

public class Rx {
    public static void ignore(Object arg) {
    }

    public static <E, R> Observable<Void> sequential(Iterator<E> iterator, Function<E, Observable<R>> action) {
        return Observable.create(collectorSubscriber ->
                Observable.<Void>create(producerSubscriber ->
                        producerSubscriber.setProducer(ignoredCount -> {
                            if (!iterator.hasNext()) {
                                producerSubscriber.onCompleted();
                                return;
                            }

                            E model = iterator.next();
                            action.apply(model)
                                    .subscribe(
                                            Rx::ignore,
                                            producerSubscriber::onError,
                                            () -> producerSubscriber.onNext(null));
                        }))
                        .subscribe(new Subscriber<Void>() {
                            @Override
                            public void onStart() {
                                request(1);
                            }

                            @Override
                            public void onCompleted() {
                                collectorSubscriber.onNext(null);
                                collectorSubscriber.onCompleted();
                            }

                            @Override
                            public void onError(Throwable e) {
                                collectorSubscriber.onError(e);
                            }

                            @Override
                            public void onNext(Void aVoid) {
                                request(1);
                            }
                        }));
    }
}

示例用法是：

    Iterator<? extends Model> iterator = models.iterator();

    Rx.sequential(iterator, model -> someFunctionReturnsObservable(model))
            .subscribe(...);

这种方法保证了链接的执行

Observable<Dummy> someFunctionReturnsObservable(Model model)

Answer 3

目前，创建observable的首选方法是使用fromAsync：

Observable.fromAsync(new Action1<AsyncEmitter<Object>>()
    {
        @Override
        public void call(final AsyncEmitter<Object> emitter)
        {
            emitter.onNext(object);
            emitter.onCompleted();

            emitter.setCancellation(new AsyncEmitter.Cancellable()
            {
                @Override
                public void cancel() throws Exception
                {
                    // on unSubscribe() callback
                }
            });
        }
    }, AsyncEmitter.BackpressureMode.BUFFER);