在 RxJava 中替换 MediatorLiveData

Question

主要问题是我是 RxJava 和 Retrofit 的新手。我想做的是使用

case1：网络可用 -> 从网络获取数据并将其添加到数据库

case2：网络不可用->从数据库中获取陈旧数据

对于这些我现在正在使用这些 google 示例，我有两个问题要重新调整 Google 示例 NetworkBoundResource：

1. 我们如何使用 Rxjava 而不是Exectuors 和 LiveData 编写这个 Google NetworkBoundResource class ？
2. 我想知道什么可以用来替换RxJava 中的 MediatorLiveData ？

下面的示例代码来自谷歌。

public abstract class NetworkBoundResource<CacheObject, RequestObject> {

private static final String TAG = "NetworkBoundResource";

private AppExecutors appExecutors;
private MediatorLiveData<Resource<CacheObject>> results = new MediatorLiveData<>();

public NetworkBoundResource(AppExecutors appExecutors) {
    this.appExecutors = appExecutors;
    init();
}

private void init(){

    // update LiveData for loading status
    results.setValue((Resource<CacheObject>) Resource.loading(null));

    // observe LiveData source from local db
    final LiveData<CacheObject> dbSource = loadFromDb();

    results.addSource(dbSource, new Observer<CacheObject>() {
        @Override
        public void onChanged(@Nullable CacheObject cacheObject) {

            results.removeSource(dbSource);

            if(shouldFetch(cacheObject)){
                // get data from the network
                fetchFromNetwork(dbSource);
            }
            else{
                results.addSource(dbSource, new Observer<CacheObject>() {
                    @Override
                    public void onChanged(@Nullable CacheObject cacheObject) {
                        setValue(Resource.success(cacheObject));
                    }
                });
            }
        }
    });
}

/**
 * 1) observe local db
 * 2) if <condition/> query the network
 * 3) stop observing the local db
 * 4) insert new data into local db
 * 5) begin observing local db again to see the refreshed data from network
 * @param dbSource
 */
private void fetchFromNetwork(final LiveData<CacheObject> dbSource){

    Log.d(TAG, "fetchFromNetwork: called.");

    // update LiveData for loading status
    results.addSource(dbSource, new Observer<CacheObject>() {
        @Override
        public void onChanged(@Nullable CacheObject cacheObject) {
            setValue(Resource.loading(cacheObject));
        }
    });

    final LiveData<ApiResponse<RequestObject>> apiResponse = createCall();

    results.addSource(apiResponse, new Observer<ApiResponse<RequestObject>>() {
        @Override
        public void onChanged(@Nullable final ApiResponse<RequestObject> requestObjectApiResponse) {
            results.removeSource(dbSource);
            results.removeSource(apiResponse);

            /*
                3 cases:
                   1) ApiSuccessResponse
                   2) ApiErrorResponse
                   3) ApiEmptyResponse
             */

            if(requestObjectApiResponse instanceof ApiResponse.ApiSuccessResponse){
                Log.d(TAG, "onChanged: ApiSuccessResponse.");

                appExecutors.diskIO().execute(new Runnable() {
                    @Override
                    public void run() {

                        // save the response to the local db
                        saveCallResult((RequestObject) processResponse((ApiResponse.ApiSuccessResponse)requestObjectApiResponse));

                        appExecutors.mainThread().execute(new Runnable() {
                            @Override
                            public void run() {
                                results.addSource(loadFromDb(), new Observer<CacheObject>() {
                                    @Override
                                    public void onChanged(@Nullable CacheObject cacheObject) {
                                        setValue(Resource.success(cacheObject));
                                    }
                                });
                            }
                        });
                    }
                });
            }
            else if(requestObjectApiResponse instanceof ApiResponse.ApiEmptyResponse){
                Log.d(TAG, "onChanged: ApiEmptyResponse");
                appExecutors.mainThread().execute(new Runnable() {
                    @Override
                    public void run() {
                        results.addSource(loadFromDb(), new Observer<CacheObject>() {
                            @Override
                            public void onChanged(@Nullable CacheObject cacheObject) {
                                setValue(Resource.success(cacheObject));
                            }
                        });
                    }
                });
            }
            else if(requestObjectApiResponse instanceof ApiResponse.ApiErrorResponse){
                Log.d(TAG, "onChanged: ApiErrorResponse.");
                results.addSource(dbSource, new Observer<CacheObject>() {
                    @Override
                    public void onChanged(@Nullable CacheObject cacheObject) {
                        setValue(
                                Resource.error(
                                        ((ApiResponse.ApiErrorResponse) requestObjectApiResponse).getErrorMessage(),
                                        cacheObject
                                )
                        );
                    }
                });
            }
        }
    });
}

private CacheObject processResponse(ApiResponse.ApiSuccessResponse response){
    return (CacheObject) response.getBody();
}

private void setValue(Resource<CacheObject> newValue){
    if(results.getValue() != newValue){
        results.setValue(newValue);
    }
}

// Called to save the result of the API response into the database.
@WorkerThread
protected abstract void saveCallResult(@NonNull RequestObject item);

// Called with the data in the database to decide whether to fetch
// potentially updated data from the network.
@MainThread
protected abstract boolean shouldFetch(@Nullable CacheObject data);

// Called to get the cached data from the database.
@NonNull @MainThread
protected abstract LiveData<CacheObject> loadFromDb();

// Called to create the API call.
@NonNull @MainThread
protected abstract LiveData<ApiResponse<RequestObject>> createCall();

// Returns a LiveData object that represents the resource that's implemented
// in the base class.
public final LiveData<Resource<CacheObject>> getAsLiveData(){
    return results;
};

}