Comment faire de plusieurs demande et attendre jusqu'à ce que les données sont venus de toutes les demandes pour le rétrofit 2.0 - android

Le propre et soigné approche d'attendre jusqu'à ce que l'ensemble de vos demandes sera faite, c'est d'utiliser Retrofit2 en conjonction avec RxJava2 et ses zip fonction.

Ce zip n'est fondamentalement construit de nouvelles observables qui attend jusqu'à ce que toutes vos rénovations Observable demandes sera fait et puis il émet son propre résultat.

Voici un exemple Retrofit2 interface avec Observables:

public interface MyBackendAPI {
  @GET("users/{user}")
  Observable<User> getUser(@Path("user") String user);

  @GET("users/{user}/photos")
  Observable<List<Photo>> listPhotos(@Path("user") String user);

  @GET("users/{user}/friends")
  Observable<List<User>> listFriends(@Path("user") String user);
}

Dans le code où vous allez faire de multiples demandes et seulement après que tous d'entre eux vont terminer de faire quelque chose d'autre, vous pouvez ensuite écrire le code suivant:

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .build();

    MyBackendAPI backendApi = retrofit.create(MyBackendAPI.class);

    List<Observable<?>> requests = new ArrayList<>();

    //Make a collection of all requests you need to call at once, there can be any number of requests, not only 3. You can have 2 or 5, or 100.
    requests.add(backendApi.getUser("someUserId"));
    requests.add(backendApi.listPhotos("someUserId"));
    requests.add(backendApi.listFriends("someUserId"));

    //Zip all requests with the Function, which will receive the results.
    Observable.zip(
            requests,
            new Function<Object[], Object>() {
                @Override
                public Object apply(Object[] objects) throws Exception {
                    //Objects[] is an array of combined results of completed requests

                    //do something with those results and emit new event
                    return new Object();
                }
            })
            //After all requests had been performed the next observer will receive the Object, returned from Function
            .subscribe(
                    //Will be triggered if all requests will end successfully (4xx and 5xx also are successful requests too)
                    new Consumer<Object>() {
                        @Override
                        public void accept(Object o) throws Exception {
                            //Do something on successful completion of all requests
                        }
                    },

                    //Will be triggered if any error during requests will happen
                    new Consumer<Throwable>() {
                        @Override
                        public void accept(Throwable e) throws Exception {
                            //Do something on error completion of requests
                        }
                    }
            );

C'est tout 🙂

---

Juste au cas où veux montrer comment le même code ressemble à Kotlin.

    val retrofit = Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .build()

    val backendApi = retrofit.create(MyBackendAPI::class.java)

    val requests = ArrayList<Observable<*>>()

    requests.add(backendApi.getUser())
    requests.add(backendApi.listPhotos())
    requests.add(backendApi.listFriends())

    Observable
            .zip(requests) {
                //do something with those results and emit new event
                Any() //<-- Here we emit just new empty Object(), but you can emit anything
            }
            //Will be triggered if all requests will end successfully (4xx and 5xx also are successful requests too)
            .subscribe({
                //Do something on successful completion of all requests
            }) {
                //Do something on error completion of requests
            }

OriginalL'auteur Клаус Шварц

Si vous n'avez pas l'esprit en ajoutant encore une dépendance que vous pourriez utiliser RxAndroid.
En particulier, vous devriez changer votre interface de Service, avec quelque chose de similaire à ceci:

@GET("/data")
Observable<ResponseWrap> getNewsData();

Maintenant, vous pouvez faire ceci:

Observable
            .range(0, **numberOfTimes**, Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .doOnError(new Action1<Throwable>() {
                @Override
                public void call(Throwable throwable) {
                    Log.e("error", throwable.toString());
                }
            })
            .concatMap(new Func1<Integer, Observable<ResponsWrapper>>() {
                @Override
                public Observable<ResponsWrapper> call(Integer integer) {
                    Log.i("news", "nr:" + integer);
                    //Does the call.
                    return service.getNewsData(integer);
                }
            }).concatMap(new Func1<ResponsWrapper, Observable<News>>() {
        @Override
        public Observable<News> call(final ResponsWrapper responsWrapper) {
            return Observable.fromCallable(new Func0<News>() {
                @Override
                public News call() {
                    //change the result of the call to a news.
                    return new News(responsWrapper.category,responsWrapper.title,null);
                }
            });
        }
    }).toList().subscribe(new Action1<List<News>>() {
        @Override
        public void call(List<News> newList) {
           AdapterRecommendation adapter = new AdapterRecommendation(getApplicationContext(), newsList);
           listView.setAdapter(adapter);
        }
    });

Il suffit de changer numberOfTimes et il va fonctionner! Espérons que cela aide.

P. s. peut-être qu'il y a de plus propre de façons de le faire.

OriginalL'auteur Jibbo