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

Question

我是 RxJava 的超级初级者，如果有更好的方法，我可能需要找到更好的方法。

我正在开发遗留的

Loader

代码，我想用 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() {...}
}

因此，我的 Presenter 类正在寻找最新的 Booking 对象，以便将用户引导到下一个屏幕（基于 Booking 的状态）。

final class Presenter {
    void findLatestBooking() {
        CurrentBookingLoaderManager.newInstance(mContext)
                .getPendingBooking(mActivity, new CurrentBookingLoaderManager.OnPendingBooking() {
                    @Override
                    public void found(Booking booking) {
                        ...
                    }
                });
    }
}

回到

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);
                    }
                });
    }

让我觉得这不是正确的方法是使用 RxJava 有很多行，而 Rx 通常会减少代码行数。可能有更好的方法吗？

根据我的测试，此代码运行良好。

Answer 1

1. RetroLambda
2. SqlBrite代替AsyncTaskLoader
3. 如果可能的话Realm而不是sqlite。

4. subscribeOn(Schedulers.newThread())

   ->

   subscribeOn(Schedulers.io())

   （无需每次创建新线程）

5. 还有

   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());
    }
}

和

Observable
   .compose(RxUtil::applySchedulers)