简化三重嵌套循环，以避免在Android Retrofit2中回调地狱（通过RxJava2吗？）

Question

Context

Using android retrofit2, need to access deeply nested name strings to fetch and display their Details (where Detail s object has reference to the Group and User objects used to get the Detail ).

The JSON consists of a list of Group s that each contain a list of User s that each contain a list of name String s which are captured in these models:

public class Group {
    @SerializedName("id")
    public String id;
    @SerializedName("users")
    public List<User> users;
}
public class User {
    @SerializedName("id")
    public String id;
    @SerializedName("detailNames")
    public List<String> detailNames;
}
public class Detail {
    // allow access to objects used to get detail
    public Group group;
    public User user;
    @SerializedName("name")
    public String name;
    @SerializedName("description")
    public String description;
}

The models are populated using the UserApi :

public interface UserApi {
    @GET("groups")
    Call<List<Group>> getGroups();

    @GET("groups/{group_id}/users/{user_id}/details/{detail_name}")
    Call<Detail> getDetail(
            @Path("group_id") String groupId,
            @Path("user_id") String userId,
            @Path("detail_name") String detailName
    );
}

Aim

The aim is to use a given UserApi to make and parse requests to display a Dialog in the format of:

Group1 (expandable heading)
    User1 (expandable heading)
        Detail1 (checkbox)
        Detail2 (checkbox)
        ...
Group2 (expandable heading)
    User2 (expandable heading)
        Detail1 (checkbox)
        ...
    ...
...

Problem

The problem is the current solution requests Group s and uses a triple nested for loop to access and fetch Detail s for each name :

private void fetchDetails(List<Group> groupList) {
    ArrayList<Group> groups = (ArrayList<Group>) groupList;
    if (groups != null && groups.size() > 0) {
        for (Group group : groups) {
            for (User user: group.users) {
                for (String detailName : user.detailNames) {
                    fetchDetail(group, user, detailName);
                }
            }
        }
    }
}

The problem is worsened since the triple loop makes a request for each name , and is done within the getGroups onResponse callback, which seems unreadable/unmaintainable:

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    mUserApi = UserApiClient.getApi();
    fetchGroups();
}
private void fetchGroups() {
    Callback<List<Group>> groupsCall = new Callback<List<Group>>() {
        @Override
        public void onResponse(Call<List<Group>> call, Response<List<Group>> response) {
            int statusCode = response.code();
            switch (statusCode) {
                case HttpURLConnection.HTTP_OK:
                    List<Group> groups = response.body();
                    fetchDetails(groups);
                    break;
            }
        }
        @Override
        public void onFailure(Call<List<Group>> call, Throwable t) {}
    };
    mUserApi.getGroups().enqueue(groupsCall);
}
private void fetchDetail(final Group group, final User user, String detailName) {
    Callback<Detail> detailCallback= new Callback<Detail>() {
        @Override
        public void onResponse(Call<Detail> call, Response<Detail> response) {
            int statusCode = response.code();
            switch (statusCode) {
                case HttpURLConnection.HTTP_OK:
                    MainActivity.this.runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            // display details in ListView
                        }
                    });
                    break;
            }
        }
        @Override
        public void onFailure(Call<Detail> call, Throwable t) {}
    };
    mUserApi.getDetail(group.id, user.id, detailName).enqueue(detailCallback);
}

An RxJava2 solution was suggested to avoid nesting callbacks like the above implementation, but was unfinished due to confusion regarding managing 3 layers of nesting to access the names :

Observable<List<Group>> groupCall =  mUserApi.getGroups();
groupCall.flatMapIterable(x -> x)
   .flatMap(group -> {
       Observable.fromIterable(group.users)
           .flatMap(user -> {
               Observable.fromIterable(user.detailNames)
                   .map(detailName -> {
                        mUserApi.getDetail(group.id, user.id, detailName)
                            .flatMap(detail -> {
                                detail.group = group;
                                detail.user = user;
                                return Observable.just(detail)
                            })
                            .subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .subscribe(new Observer<List<Group>>() {
                                @Override
                                public void onSubscribe(Disposable d) {}
                                @Override
                                public void onNext(List<Detail> value) {
                                    mDetails = (ArrayList<Detail>) value;
                                }
                                @Override
                                public void onError(Throwable e) {}
                                @Override
                                public void onComplete() {}
                            });
                   });
           }
   })

There have been some questions (eg, RxJava multiple loop with condition ) that deal with nesting in RxJava but still unsure how to apply these to the deeply nested name s.

Question

Is it possible to use RxJava2 to avoid callback hell and simplify the triple for loop, is there another way, or should the solution resort to synchronous requests within AsyncTask / AsyncTaskLoader ?

Answer 1

As I mentioned in the comment, I think what you already have is pretty much the simplest form you can get. But it seems you are interested in doing this without the loop so here's a couple of suggestions (but not necessarily better):

Method 1: Container Classes

If you are willing to create intermediate container classes that can hold group, user, detailname in a single object, you can do something like this:

First, create these container classes:

public class UserWithGroup {
    final Group group;
    final User user;

    public UserWithGroup(Group group, User user) {
        this.group = group;
        this.user = user;
    }
}

public class DetailWithUser {
    final Group group;
    final User user;
    final String detailName;

    public DetailWithUser(Group group, User user, String detailName) {
        this.group = group;
        this.user = user;
        this.detailName = detailName;
    }
}

Then your code with Java 8 Stream can be:

private void fetchDetails(List<Group> groupList) {
    groupList.stream()
            .flatMap(g -> g.users.stream().map(u -> new UserWithGroup(g, u)))
            .flatMap(ug -> ug.user.detailNames.stream().map(n -> new DetailWithUser(ug.group, ug.user, n)))
            .forEach(d -> fetchDetail(d.group, d.user, d.detailName));
}

Or with RxJava:

private void fetchDetails2(List<Group> groupList) {
    Observable.fromIterable(groupList)
            .flatMap(g -> Observable.fromIterable(g.users).map(u -> new UserWithGroup(g, u)))
            .flatMap(ug -> Observable.fromIterable(ug.user.detailNames).map(n -> new DetailWithUser(ug.group, ug.user, n)))
            .flatMap(d -> mUserApi.getDetail(d.group.id, d.user.id, d.detailName)
                    .map(detail -> {
                        detail.group = d.group;
                        detail.user = d.user;
                        return detail
                    }))
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(detail -> {
                ...
            });
}

Method2:

Android.util.Pair a container class that can hold any two objects. If you use this instead of creating intermediate containers, and you are okay with it, the code can be further simplified.

Java 8 Stream and Pair:

private void fetchDetails3(List<Group> groupList) {
    groupList.stream()
            .flatMap(g -> g.users.stream().map(u -> Pair.create(g, u)))
            .flatMap(p -> p.second.detailNames.stream().map(n -> Pair.create(p, n)))
            .forEach(p -> fetchDetail(p.first.first, p.first.second, p.second));
}

RxJava and Pair:

private void fetchDetails4(List<Group> groupList) {
    Observable.fromIterable(groupList)
            .flatMap(g -> Observable.fromIterable(g.users).map(u -> Pair.create(g, u)))
            .flatMap(p -> Observable.fromIterable(p.second.detailNames).map(n -> Pair.create(p, n)))
            .flatMap(p -> fetchDetail2(p.first.first, p.first.second, p.second)
                    .map(detail -> {
                        detail.group = d.group;
                        detail.user = d.user;
                        return detail
                    }))
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(detail -> {
                ...
            });
}