我有几个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(...);