web-dev-qa-db-fra.com

demande d'api multiple utilisant retrofit et rx java

Je suis nouveau sur Android et j'ai un scénario où je veux obtenir des données de plusieurs API. Supposons api_a, api_b, api_c, api_d. Ces api sont indépendants les uns des autres mais je veux afficher les données de ces api dans une vue Recycler mix (horizontal et vertical Je veux donc faire ces appels api de telle manière que je puisse obtenir toutes les données api à la fois afin que je puisse les afficher dans la vue du recycleur. J'utilise déjà retrofit 2 mais pour cela je a dû les enchaîner un par un, ce qui est très long et je pense que ce n'est pas une approche possible. Je connais peu RX Java, mais je ne sais comment faire qu'une seule demande à la fois. Aidez-moi

androidretrofitretrofit2rx-java2rx-android
7
Android

Il y a au moins 2 façons d'y parvenir -

1) Utilisation de l'opérateur Zip RxJava (pour les requêtes parallèles)

Obtenez tous les observables

Observable<ResponseType1> observable1 = retrofit.getApi_a();
Observable<ResponseType2> observable2 = retrofit.getApi_b();
Observable<ResponseType3> observable3 = retrofit.getApi_c();

Zip les observables pour obtenir un observable final

Observable<List<String>> result = 
Observable.Zip(observable1.subscribeOn(Schedulers.io()), observable2.subscribeOn(Schedulers
            .io()), observable3.subscribeOn(Schedulers.io()), new Function3<ResponseType1, ResponseType2, ResponseType3, List<String>>() {
    @Override
    public List<String> apply(ResponseType1 type1, ResponseType2 type2, ResponseType3 type3) {
        List<String> list = new ArrayList();
        list.add(type1.data);
        list.add(type2.data);
        list.add(type3.data);
        return list;
    }
});

abonnez-vous maintenant sur le résultat observable

result.observeOn(AndroidSchedulers.mainThread())
            .subscribeWith(new Observer<List<String>>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(List<String> s) {
                    Log.d(TAG, "s is the list with all the data");
                }

                @Override
                public void onError(Throwable e) {
                    Log.e(TAG, e.getMessage());
                }

                @Override
                public void onComplete() {

                }
            });

2) Utilisation de l'opérateur RxJava flatMap (). (Pour demander en série les uns après les autres)

Il s'agit d'un simple enchaînement de demandes

    List<String> result = new ArrayList<>();
    Disposable disposable = retrofit.getApi_a()
            .subscribeOn(Schedulers.io())
            .flatMap((Function<ResponseType1, ObservableSource<ResponseType2>>) response1 -> {
                result.add(response1.data);
                return retrofit.getApi_b();
            })
            .flatMap((Function<ResponseType2, ObservableSource<ResponseType3>>) response2 -> {
                result.add(response2.data);
                return retrofit.getApi_c();
            })
            .map(response3 -> {
                result.add(response3.data);
                return response3;
            })
            .observeOn(AndroidSchedulers.mainThread())
            .subscribeWith(new DisposableObserver<Response3>() {

                @Override
                public void onNext(Response3 response3) {
                    Log.d(TAG, "result variable will have all the data");
                }

                @Override
                public void onError(Throwable e) {
                    Log.e(TAG, e.getMessage());
                }

                @Override
                public void onComplete() {

                }
            });
13
Ankit Aggarwal

L'opérateur de fusion combine plusieurs observables en un

Configurer l'URL de base de l'API:

Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(Constants.BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                    .client(oktHttpClient.build())
                    .build();

Configurez maintenant deux observables pour les deux requêtes réseau:

Observable<JsonElement> Observable1 = ApiClient.getApiService().getApi_1();

Observable<JsonElement> Observable2 = ApiClient.getApiService().getApi_2();

Nous utilisons maintenant la méthode de fusion de RxJava pour combiner nos deux observables:

Observable.merge(Observable1, Observable2 )
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<JsonElement>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(JsonElement value) {
                        Log.d("RESPONSE", "onNext:=======" + value);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        Log.d("RESPONSE", "DONE==========");
                    }
                });
0
Sayan Manna

Pour combiner plusieurs observables, vous pouvez envisager l’opérateur Fusionner . Cela vous permettrait de combiner le flux de plusieurs demandes en un seul observable.

La fusion les entrelacera au fur et à mesure de leur émission. Si la séquence est importante, il y a aussi Concat qui émettra de chaque observable avant de continuer avec le suivant.

Doc Rx

0
Shazbot