Android 用RxJava2替换AsyncTaskLoader的最佳方法是什么？

我是RxJava的超级初级，如果我选择了一个不好的方法或者有更好的方法，我需要帮助找到一个更好的方法

我正在开发一个遗留的

加载程序

代码，我想用RxJava替换它。 我的原始代码中包含以下内容：

public class CurrentBookingLoaderManager extends AsyncTaskLoader<Booking> {
    ...

    @Override
    public Booking loadInBackground() {
        try {
            return createPendingBookingObserver().blockingGet(); // Gets last Booking from back-end
        } catch (Exception e) {
            Logger.logCaughtException(e);
            return loadPendingBookingFromDB();
        }
    }

    private Single<Booking> createPendingBookingObserver() {...}

    private Booking loadPendingBookingFromDB() {...}
}

回到

CurrentBookingLoaderManager

，我创建了一个接口和一些方法，以便以Rx方式重构

loadInBackground（）

的功能

    public interface OnPendingBooking {
        void found(Booking booking);
    }

    public void getPendingBooking(final MyActivity activity, final OnPendingBooking callback) {
        CurrentBookingLoaderManager.newInstance(activity)
                .createPendingBookingObserver()
                .compose(activity.<Booking>asyncCallWithinLifecycle())
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Booking>() {
                    @Override
                    public void accept(Booking booking) throws Exception {
                        callback.found(booking);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        loadPendingBookingFromDB(activity, callback);
                    }
                });
    }

    private void loadPendingBookingFromDB(final MyActivity activity, final OnPendingBooking callback) {
        Single.fromCallable(new Callable<Booking>() {
            @Override
            public Booking call() throws Exception {
                return loadPendingBookingFromDB();
            }
        })
                .compose(activity.<Booking>asyncCallWithinLifecycle())
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Booking>() {
                    @Override
                    public void accept(Booking booking) throws Exception {
                        callback.found(booking);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        callback.found(null);
                    }
                });
    }

公共界面挂起预订{
发现无效（预订）；
}
公共作废getPendingBooking（最终MyActivity活动，最终OnPendingBooking回调）{
CurrentBookingLoaderManager.newInstance（活动）
.createPendingBookingObserver（）
.compose（activity.asyncCallWithinLifecycle（））
.subscribeOn（Schedulers.newThread（））
.observeOn（AndroidSchedulers.mainThread（））
.订阅（新消费者）{
@凌驾
公共作废接受（预订）引发异常{
找到（预订）；
}
}，新消费者（）{
@凌驾
public void accept（Throwable Throwable）引发异常{
loadPendingBookingFromDB（活动，回调）；
}
});
}
私有void loadPendingBookingFromDB（最终MyActivity活动，最终OnPendingBooking回调）{
Single.fromCallable（new Callable（））{
@凌驾
公共预订调用（）引发异常{
返回loadPendingBookingFromDB（）；
}
})
.compose（activity.asyncCallWithinLifecycle（））
.subscribeOn（Schedulers.newThread（））
.observeOn（AndroidSchedulers.mainThread（））
.订阅（新消费者）{
@凌驾
公共作废接受（预订）引发异常{
找到（预订）；
}
}，新消费者（）{
@凌驾
public void accept（Throwable Throwable）引发异常{
callback.found（null）；
}
});
}

让我觉得这种方法不正确的是，使用RxJava有很多行，而Rx通常会减少代码行数。所以，如果你认为有更好的方法，请给我一些建议

根据我的测试，这段代码运行良好

而不是AsyncTaskLoader

如果可能的话，用sqlite代替

subscribeOn（Schedulers.newThread（））

->

subscribeOn（Schedulers.io（））

（无需每次创建新线程）

及

Observable
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())

可以替换为

public class RxUtil {

    public static <T> Observable.Transformer<T, T> applySchedulers() {
        return observable -> observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }
}

---

rxjava1还是rxjava2？两者的类有一点不同。@Saurabh RxJava 2实际上，谢谢你的提问：）我刚刚更新了我的问题。唯一可以改进的是使用

subscribeOn（Schedulers.io（））

，而不是每次都创建一个新线程。休息对我来说很好谢谢你的观点。不幸的是，我无法彻底检查应用程序的结构：（它如何处理配置更改（如更改方向）？离线优先，无需处理任何事情-所有状态都将在DB中

public class RxUtil {

    public static <T> Observable.Transformer<T, T> applySchedulers() {
        return observable -> observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }
}

Observable
   .compose(RxUtil::applySchedulers)