3

这是工作代码，但我有几个问题以及关于改进它的建议请求。我是 RxJava 的新手，我还没有完全理解如何将这些类型的 observables 链接在一起。

我有两个模型对象，ListItem和UserInfo. ListItems 存在于本地数据库中，并且UserInfo使用ListItem.

Web 服务接受一UserInfo组 ID，它将为其返回一个UserInfo对象列表。

这段代码的流程如下：

  1. ListItem从数据库中加载
  2. 使用ListItem从数据库中获取的 s，检查内存缓存以查看我是否已经获取UserInfo了特定的ListItem
  3. 对于任何UserInfo未缓存的项目，从网络中获取它们
  4. 将获取的UserInfo对象放入缓存中
  5. 重新运行第2步（方法是loadCachedUserInfo）
  6. 将结果返回给订阅者

注意：仅当列表已被视为 a 时，UserInfo才应为 a 获取对象。ListItemisUserList

这是代码：

fun itemsInList(list : ATList, parentValue : String? = null, searchString : String? = null, limit : Int = defaultFetchLimit, sortOrder: SortDescriptor? = null) : Observable<List<ATListItem>> {
    return Observable.create<List<ATListItem>> { subscriber ->
        val listItems = listItemsInList(list, parentValue = parentValue, searchString = searchString, limit = limit, sortOrder = sortOrder)
        subscriber.onNext(listItems)
        subscriber.onCompleted()
    }.flatMap { listItems ->
        if ( list.isUserList ) {
            return@flatMap loadCachedUserInfo(listItems, userIDIndex = list.userIDIndex!!)
        }
        return@flatMap Observable.just(listItems)
    }.flatMap { listItems ->
        if ( list.isUserList ) {
            return@flatMap fetchUserInfoForListItems(listItems, list.userIDIndex!!, force = false)
        }
        return@flatMap Observable.just(listItems)
    }
}

fun loadCachedUserInfo(listItems : List<ATListItem>, userIDIndex : Int) : Observable<List<ATListItem>> {
    return Observable.create<List<ATListItem>> { subscriber ->
        for ( listItem in listItems ) {
            listItem.coreUserInfo = coreUserMap[listItem.valueForAttributeIndex(userIDIndex)?.toLowerCase()]
        }
        subscriber.onNext(listItems)
        subscriber.onCompleted()
    }
}

fun fetchUserInfoForListItems(listItems : List<ATListItem>, userIDIndex: Int, force: Boolean) : Observable<List<ATListItem>> {
    val itemsToFetch = if ( force ) listItems else listItems.filter { it.coreUserInfo == null }
    val ids = itemsToFetch.map { it.valueForAttributeIndex(userIDIndex) ?: "" }.filter { !it.isEmpty() }
    val records = hashMapOf("records" to ids)
    if ( itemsToFetch.count() == 0 ) {
        return Observable.just(listItems)
    }
    return RuntimeDataController.dataService.fetchCoreUserInfo(recordsMap = records)
            .map { json ->
                val recordsArray = json.arrayValue("records")
                for ( i in 0..recordsArray.length() - 1) {
                    val coreUserInfo = CoreUserInfo(recordsArray.getJSONObject(i))
                    coreUserMap[coreUserInfo.username.toLowerCase()] = coreUserInfo
                    coreUserMap[coreUserInfo.userID] = coreUserInfo
                    coreUserInfo.externalUserID?.let { coreUserMap[it] = coreUserInfo }
                }
                return@map listItems
            }.flatMap { loadCachedUserInfo(listItems, userIDIndex = userIDIndex) }
}

用户将通过调用以下命令来启动事件序列：

ListController.itemsInList(list)

我对这段代码的问题是：

  1. 当前loadCachedUserInfo接收一个数组，ListItem并在缓存项与它关联后返回相同的数组作为可观察对象。这对我来说感觉不对。我认为这个调用应该只返回UserInfo与其关联的缓存项。但是，我需要继续将完整数组传递ListItem给下一个方法

2.) 我需要做额外的工作来支持退订吗？

3.) 这是类似的问题 1. MyfetchUserInfoForListItems接受一个列表项数组，并在它们被获取并通过缓存方法重新运行后返回一个具有相同列表项数组的 observable。这对我来说也是不正确的。我宁愿这个方法Observable<List<UserInfo>>为获取的对象返回一个。我不明白如何itemsInList将ListItems 与新获取的相关联并返回这些sUserInfo的 Observable 。ListItem

编辑：写完这篇文章后，它帮助我意识到了一些事情。我可以 flatMap 将我的调用包装在一个 Observable.create 中，它可以包含我想从我的 .create 中取出的智能fetchUserInfoForListItems，让我解决问题 #3。这是更新的代码：

 fun itemsInList(list : ATList, parentValue : String? = null, searchString : String? = null, limit : Int = defaultFetchLimit, sortOrder: SortDescriptor? = null) : Observable<List<ATListItem>> {
    return Observable.create<List<ATListItem>> { subscriber ->
        val listItems = listItemsInList(list, parentValue = parentValue, searchString = searchString, limit = limit, sortOrder = sortOrder)
        subscriber.onNext(listItems)
        subscriber.onCompleted()
    }.flatMap { listItems ->
        if ( list.isUserList ) {
            return@flatMap loadCachedUserInfo(listItems, userIDIndex = list.userIDIndex!!)
        }
        return@flatMap Observable.just(listItems)
    }.flatMap { listItems ->
        if ( list.isUserList ) {
            return@flatMap Observable.create<List<ATListItem>> { subscriber ->
                fetchUserInfoForListItems(listItems, list.userIDIndex!!, force = false).map { userInfoList ->
                    for (coreUserInfo in userInfoList) {
                        coreUserMap[coreUserInfo.username.toLowerCase()] = coreUserInfo
                        coreUserMap[coreUserInfo.userID] = coreUserInfo
                        coreUserInfo.externalUserID?.let { coreUserMap[it] = coreUserInfo }
                    }
                }.flatMap {
                    loadCachedUserInfo(listItems, userIDIndex = list.userIDIndex!!)
                }.subscribe {
                    subscriber.onNext(listItems)
                    subscriber.onCompleted()
                }
            }
        }
        return@flatMap Observable.just(listItems)
    }
}

fun loadCachedUserInfo(listItems : List<ATListItem>, userIDIndex : Int) : Observable<List<ATListItem>> {
    return Observable.create<List<ATListItem>> { subscriber ->
        listItems.forEach { listItem -> listItem.coreUserInfo = coreUserMap[listItem.valueForAttributeIndex(userIDIndex)?.toLowerCase()] }
        subscriber.onNext(listItems)
        subscriber.onCompleted()
    }
}

fun fetchUserInfoForListItems(listItems : List<ATListItem>, userIDIndex: Int, force: Boolean) : Observable<List<CoreUserInfo>> {
    val itemsToFetch = if ( force ) listItems else listItems.filter { it.coreUserInfo == null }
    val ids = itemsToFetch.map { it.valueForAttributeIndex(userIDIndex) ?: "" }.filter { !it.isEmpty() }
    val records = hashMapOf("records" to ids)
    if ( itemsToFetch.count() == 0 ) { return Observable.just(ArrayList<CoreUserInfo>()) }
    return RuntimeDataController.dataService.fetchCoreUserInfo(recordsMap = records)
            .map { json ->
                val userInfo = ArrayList<CoreUserInfo>()
                json.arrayValue("records").eachObject { userInfo.add(CoreUserInfo(it)) }
                return@map userInfo
            }
}
4

1 回答 1

3
  1. 目前 loadCachedUserInfo 接受一个 ListItem 数组，并在缓存项与其关联后返回相同的数组作为可观察对象。这对我来说感觉不对。我认为这个调用应该只返回具有与之关联的缓存 UserInfo 的项目。但是，我需要继续将 ListItem 的完整数组传递给下一个方法

我不确定我是否正确理解你，但如果你只需要副作用（缓存），你可以使用doOnNext. 例如，

.doOnNext { listItems ->
    if ( list.isUserList ) {
        cache(listItems, userIDIndex = list.userIDIndex!!)
    }
}

fun cache(listItems : List<ATListItem>, userIDIndex : Int) {
    // caching
}
  1. 我需要做额外的工作来支持退订吗？

不，AFAIK。

笔记：

更多信息doOnNext可以在What is the purpose of doOnNext(...) in RxJava和这里找到

return@...通常，如果 lambda 中的最后一条语句是表达式，则不需要。例如：

.flatMap { listItems ->
    if ( list.isUserList ) {
        return@flatMap loadCachedUserInfo(listItems, userIDIndex = list.userIDIndex!!)
    }
    return@flatMap Observable.just(listItems)
}

可以写成：

.flatMap { listItems ->
    if ( list.isUserList )
        loadCachedUserInfo(listItems, userIDIndex = list.userIDIndex!!)
    else
        Observable.just(listItems)
}

我没有测试代码。

于 2016-02-20T19:10:24.450 回答