web-dev-qa-db-fra.com

Retrofit et RxJava: Comment combiner deux requêtes et accéder aux deux résultats?

J'ai besoin de faire deux demandes de services et de combiner les résultats:

ServiceA () => [{"id":1,"name":"title"},{"id":1,"name":"title"}]

ServiceB (id) => {"field":"value","field1":"value"}

Actuellement, j'ai réussi à combiner les résultats, mais je dois passer id comme paramètre au ServiceB et avoir accès au premier résultat.

Ce que j'ai essayé jusqu'à présent:

   Retrofit repo = new Retrofit.Builder()
                .baseUrl("https://api.themoviedb.org/3/genre/")
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();

        Observable<GenerosResponse> Genres  = repo
                .create(services.class)
                .getAllGeneros("movie","list","da0d692f7f62a1dc687580f79dc1e6a0")
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread());

        Observable<ResponseMovies> Movies = repo
                .create(services.class)
                .getAllMovies("28","movies","da0d692f7f62a1dc687580f79dc1e6a0",12)
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread());

        Observable<CollectionsMovies> combined = Observable.Zip(Genres, Movies, new Func2<GenerosResponse, ResponseMovies, CollectionsMovies>() {
            @Override
            public CollectionsMovies call(GenerosResponse generosResponse, ResponseMovies responseMovies) {
                return new CollectionsMovies(generosResponse, responseMovies);
            }
        });

        combined.
                subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(...);

Modifier

Solution selon la réponse de @Maxim Ostrovidov:

 private Observable<GenerosResponse> makeRequestToServiceA() {
        return  service.getAllGeneros("movie","list","da0d692f7f62a1dc687580f79dc1e6a0"); //some network call
    }

    private Observable<ResponseMovies> makeRequestToServiceB(Genre genre) {
        return service.getAllMovies(genre.getId(),"movies","da0d692f7f62a1dc687580f79dc1e6a0","created_at.asc"); //some network call based on response from ServiceA
    }

    void doTheJob() {

        makeRequestToServiceA()
        .flatMap(userResponse -> Observable.just(userResponse.getGenres()))      //get list from response
                .flatMapIterable(baseDatas -> baseDatas)
                .flatMap(new Func1<Genre, Observable<? extends ResponseMovies>>() {

                    @Override
                    public Observable<? extends ResponseMovies> call(Genre genre) {
                        return makeRequestToServiceB(genre);
                    }
                }, new Func2<Genre, ResponseMovies, CollectionsMovies>() {

                    @Override
                    public CollectionsMovies call(Genre genre, ResponseMovies responseMovies) {
                        return new CollectionsMovies(genre,responseMovies);
                    }
                }).
                subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(....);
    }
javaandroidrx-javaretrofit2
20
David Hackro

Si je comprends bien - vous devez faire une demande en fonction du résultat d'une autre demande et combiner les deux résultats. Pour cela, vous pouvez utiliser cette variante d'opérateur flatMap: Observable.flatMap (Func1 collectionSelector, Func2 resultSelector)

Renvoie un observable qui émet les résultats d'une fonction spécifiée vers la paire de valeurs émises par l'observable source et une collection spécifiée observable . enter image description here

Exemple simple pour vous indiquer comment réécrire votre code:

private Observable<String> makeRequestToServiceA() {
    return Observable.just("serviceA response"); //some network call
}

private Observable<String> makeRequestToServiceB(String serviceAResponse) {
    return Observable.just("serviceB response"); //some network call based on response from ServiceA
}

private void doTheJob() {
    makeRequestToServiceA()
            .flatMap(new Func1<String, Observable<? extends String>>() {
                @Override
                public Observable<? extends String> call(String responseFromServiceA) {
                    //make second request based on response from ServiceA
                    return makeRequestToServiceB(responseFromServiceA);
                }
            }, new Func2<String, String, Observable<String>>() {
                @Override
                public Observable<String> call(String responseFromServiceA, String responseFromServiceB) {
                    //combine results
                    return Observable.just("here is combined result!");
                }
            })
            //apply schedulers, subscribe etc
}

Utilisation de lambdas:

private void doTheJob() {
    makeRequestToServiceA()
            .flatMap(responseFromServiceA -> makeRequestToServiceB(responseFromServiceA),
                    (responseFromServiceA, responseFromServiceB) -> Observable.just("here is combined result!"))
            //...
}
30
Maksim Ostrovidov

L'opérateur que vous recherchez est flatMap()

serviceA.getAllGeneros("movie","list","da0d692f7f62a1dc687580f79dc1e6a0")
    .flatMap(genres -> serviceB.getAllMovies(genres.getId() ......))
2
LordRaydenMK