从数据库+网络加载数据(Room+Retrofit+RxJava2)

Question

我有一个示例API请求，它返回用户的WatchList列表。我想在用户加载watchlist屏幕时实现以下流程：

差异CacheWatchList与APIWatchList

i.Same->一切都很好，因为数据已经显示给用户，什么都不做。

ii.Differs->将apiwatchlist保存到本地存储，并将apiwatchlist发送到下游。

到目前为止我做了什么？

watchlist.kt

data class Watchlist(
  val items: List<Repository> = emptyList()
)

localstore.kt（Android room）

  fun saveUserWatchlist(repositories: List<Repository>): Completable {    
    return Completable.fromCallable {      
      watchlistDao.saveAllUserWatchlist(*repositories.toTypedArray())
    }
  }

  fun getWatchlist(userId: UUID): Single<Watchlist?> {
    return api.getWatchlist(userId)
  }

  fun getWatchlist(userId: UUID): Flowable<List<Repository>?> {
    val localSource: Single<List<Repository>?> =
      localStore.getUserWatchlist()
        .subscribeOn(scheduler.computation)

    val remoteSource: Single<List<Repository>> = remoteStore.getWatchlist(userId)
      .map(Watchlist::items)
      .doOnSuccess { items: List<Repository> ->
        localStore.saveUserWatchlist(items)
          .subscribeOn(scheduler.io)
          .subscribe()
      }
      .onErrorResumeNext { throwable ->
        if (throwable is IOException) {
          return@onErrorResumeNext localStore.getUserWatchlist()
        }
        return@onErrorResumeNext Single.error(throwable)
      }
      .subscribeOn(scheduler.io)

    return Single.concat(localSource, remoteSource)
  }

>

实现上述逻辑的最佳方法是什么？

我是否泄漏了DataManager中的内部订阅（请参见:DoonSuccess代码）？。当演示者被销毁时，我将处理外部订阅。

Answer 1

fun getWatchlist(userId: UUID): Observable<List<Repository>?> {
val remoteSource: Single<List<Repository>> = 
remoteStore.getWatchlist(userId)
        .map(Watchlist::items)
        .subscribeOn(scheduler.io)

return localStore.getUserWatchlist()
        .flatMapObservable { listFromLocal: List<Repository> ->
            remoteSource
                    .observeOn(scheduler.computation)
                    .toObservable()
                    .filter { apiWatchList: List<Repository> ->
                        apiWatchList != listFromLocal
                    }
                    .flatMapSingle { apiWatchList ->
                        localSource.saveUserWatchlist(apiWatchList)
                                .andThen(Single.just(apiWatchList))
                    }
                    .startWith(listFromLocal)
        }
}

分步讲解：

1. 从LocalStore加载数据
2. 每次localStore发出数据时，使用flatMapObservable订阅remoteSource。
3. 由于内部可观测数据（来自本地的初始数据和来自远程源的更新数据的新数据）的发射不止一个，因此将单个数据转换为可观测数据。
4. 将来自remoteSource的数据与来自localStore的数据进行比较，并仅在newData！=localdata.
5. 对于筛选器之后的每次发射，启动localSource以保存数据，并在完成此操作后将保存的数据作为单个数据继续。
6. 根据请求，在远程请求开始时，应该从localStore中获取数据，只需在操作符链的末尾添加startWith就可以了。