RxJava2 ne recevant pas doOnNext après toList

Question

Je travaillais sur un projet dans lequel je voulais parcourir une liste et les combiner avant de retourner les résultats. Fondamentalement, je suis en train de convertir un objet PostResponse en Post.

Certains codes pertinents.

Post.java

public class Post { 
    @NonNull private User user; 
    @NonNull private String title; 
    @NonNull private String body; 
    @NonNull private Integer id; 
} 

PostResponse.java

public final class PostResponse{ 
    private Integer userId; 
    private Integer id; 
    private String title; 
    private String body; 
} 

Obtenir les messages

@Override public Observable<List<Post>> posts() { 
     return postDataStore.getAllPosts() 
       .flatMap(postResponses -> Observable.fromIterable(postResponses) 
         .flatMap(postResponse -> postDataMapper.transform(postResponse)) 
         // Receiving output here 
         .doOnNext(post -> Log.i(TAG, "posts: " + post)) 
         .toList() 
         .toObservable() 
         // Not Receiving output here 
         .doOnNext(posts -> Log.i(TAG, "posts: " + posts))); 
    } 

Transform fonction appelée ci-dessus.

public Observable<Post> transform(final PostResponse postResponse) { 
     return Observable.create(emitter -> { 
      final Post post = new Post(postResponse.getId()); 
      post.setTitle(postResponse.getTitle()); 
      post.setBody(postResponse.getBody()); 
      userRepository.user(postResponse.getUserId()).doOnNext(user -> { 
       post.setUser(user); 
       emitter.onNext(post); 
      }).subscribe(); 
     }); 
    } 

Mais je ne reçois pas de données sur doOnNext qui est abonnée à posts(). Je ne sais pas ce qui ne va pas. Mes excuses si je commets une erreur vraiment idiote.

Answer 1

Une solution rapide serait d'ajouter:

emitter.onComplete();

juste après votre emitter.onNext(post);

MAIS, je recommande de repenser la conception et la logique. En particulier votre transformation n'a pas besoin de créer un nouveau Observable. Je redessiner votre méthode tranform quelque chose comme ceci: De cette façon

Observable<Post> transform(PostResponse postResponse) { 
    return userRepository.user(postResponse.getUserId()) 
     .map(user -> parseResponse(parseResponse, user)); 
} 


Post parseResponse(PostResponse response, User user) { 
    final Post post = new Post(postResponse.getId()); 
    post.setTitle(postResponse.getTitle()); 
    post.setBody(postResponse.getBody()); 
    post.setUser(user); 

    return post; 
} 

vous éviter de créer une nouvelle Observable, vous évitez les abonnements internes, et vous avez un point de contrôle unique pour le résultat, ce qui est dans l'abonnement du résultat final Observable.