处理列表和RxJava和改造的机器人 [英] Handling lists with RxJava and Retrofit in android

问题描述

我有几个API调用来使（连续，异步），其中一些将返回列表。我的API接口下面给出。

  @GET（/用户/设置）
可观察＆LT; UserWrapper＆GT; getUserSettings（）;

@GET（/ {用户名} /集合）
可观察＆LT;列表＆LT;项目＆GT;＆GT; getItems（@Path（用户名）字符串用户名）;

@GET（/项目/ {ID}）
可观察＆LT; ItemInfo＆GT; getItemInfo（@Path（ID）INT ID）;

@GET（/ {用户名} /朋友）
可观察＆LT;列表＆LT;朋友＆GT;＆GT; getFriends（@Path（用户名）字符串用户名）;
 

这就是我想要做的顺序：

• 获取 UserWrapper 致电 getUserSettings（）
• 在保存用户通过调用 saveUser（userWrapper）
• 通过调用获取用户的项目 getItems（userWrapper.getUserName（））
• 通过调用获取每个项目的信息 getItemInfo（item.getId（））
• 保存每个 itemInfo 致电 saveItem（itemInfo）
• 通过调用获取用户的好友 getFriends（userWrapper.getUserName（））
• 通过调用保存每个朋友 saveFriend（朋友）

现在我是新来RxJava，不知道如何处理名单。我看到的杰克沃顿商学院的幻灯片的一个，发现他使用的函数 flattenList （），但我不知道它的定义。这将是巨大的，如果你能帮助撰写这条产业链。

---

更新1

这是据我现在已经得到了：

  mApiService.getUserSettings（）
            .MAP（这:: saveUser）
            .flatMap（userWrapper  - ＆GT; mApiService.getItems（userWrapper.getUserName（）））;
            .flatMapIterable（？如何循环的每个项目？）;
 

---

更新2

我想写这样的事情

  mApiService.getUserSettings（）
    .MAP（这:: saveUser）
    .flatMap（userWrapper  - ＆GT; mApiService.getItems（userWrapper.getUserName（）））
    .someMethodToIterateThroughEachItem（项目 - ＆GT; mApiService.getItemInfo（项目））
    .MAP（这:: saveItem）
    .someMethodThatCanCallUserWrapperAgain（userWrapper  - ＆GT; mApiService.getFriends（userWrapper.getUserName（）））
    .someMethodToIterateThoughEachFriend（朋友 - ＆GT; saveFriend（朋友））
 

解决方案

RxJava增加 flatMapIterable 。所以，你不需要 flattenList 现在。例如，

 观测＆LT; UserWrapper＆GT; O =
       getUserSettings（）
       .doOnNext（这:: saveUser）
       .flatMap（用户 - ＆GT; getItems（user.getUserName（））
                        .flatMapIterable（项目 - ＆GT;项目）
                        .flatMap（项目 - ＆GT; getItemInfo（item.getId（）））
                        .doOnNext（这:: saveItem）
                        .toList（）
                        .MAP（忽略 - ＆gt;用户））
        .flatMap（用户 - ＆GT; getFriends（user.getUserName（））
                         .flatMapIterable（朋友 - ＆GT;朋友）
                         .doOnNext（这:: saveFriend）
                         .toList（）
                         .MAP（忽略 - ＆gt;用户）
        ）;
    o.subscribe（...）;
 

I have couple of api calls to make (sequentially, asynchronously) and some of them returns lists. My api interface is given below.

@GET("/users/settings")
Observable<UserWrapper> getUserSettings();

@GET("/{username}/collections")
Observable<List<Item>> getItems(@Path("username") String userName);

@GET("/item/{id}")
Observable<ItemInfo> getItemInfo(@Path("id") int id);

@GET("/{username}/friends")
Observable<List<Friend>> getFriends(@Path("username") String userName);

Here's what I want to do sequentially:

• Get UserWrapper by calling getUserSettings()
• Save the user by calling saveUser(userWrapper)
• Get user's items by calling getItems(userWrapper.getUserName())
• Get each item's information by calling getItemInfo(item.getId())
• Save each itemInfo by calling saveItem(itemInfo)
• Get user's friends by calling getFriends(userWrapper.getUserName())
• Save each friend by calling saveFriend(friend)

Now I am new to RxJava and do not know how to handle lists. I watched one of Jake Wharton's slides and found that he uses a function flattenList() but I don't know its definition. It would be great if you can help composing this chain.

---

Update 1

This is as far I've gotten now:

mApiService.getUserSettings()
            .map(this::saveUser)
            .flatMap(userWrapper -> mApiService.getItems(userWrapper.getUserName()));
            .flatMapIterable( ? "How to iterate for each item" ? );

---

Update 2

I am trying to write something like this

mApiService.getUserSettings()
    .map(this::saveUser)
    .flatMap(userWrapper -> mApiService.getItems(userWrapper.getUserName()))
    .someMethodToIterateThroughEachItem(item -> mApiService.getItemInfo(item))
    .map(this::saveItem)
    .someMethodThatCanCallUserWrapperAgain(userWrapper -> mApiService.getFriends(userWrapper.getUserName()))
    .someMethodToIterateThoughEachFriend(friend -> saveFriend(friend))

解决方案

RxJava has added flatMapIterable. So you don't need flattenList now. E.g.,

  Observable<UserWrapper> o =
       getUserSettings()
       .doOnNext(this::saveUser)
       .flatMap(user -> getItems(user.getUserName())
                        .flatMapIterable(items -> items)
                        .flatMap(item -> getItemInfo(item.getId()))
                        .doOnNext(this::saveItem)
                        .toList()
                        .map(ignored -> user))
        .flatMap(user -> getFriends(user.getUserName())
                         .flatMapIterable(friends -> friends)
                         .doOnNext(this::saveFriend)
                         .toList()
                         .map(ignored -> user)
        );
    o.subscribe(...);

这篇关于处理列表和RxJava和改造的机器人的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！