android tuto Pourquoi RxJava est-il souvent utilisé avec Retrofit?




simple retrofit example (2)

Quel est l'avantage d'utiliser Retrofit en association avec Rxjava?


Pour comprendre ces avantages, vous devez d’abord comprendre à quel point il est avantageux pour votre base d’adopter des extensions réactives.

  • Composabilité et transformation

    • Les flux offrent une interface très composable. Il vous permet d'effectuer des opérations de transformation (sur la structure et l'heure de l'événement) et d'interagir de manière transparente (telle que créer des dépendances ou exploiter le résultat / l'erreur d'un autre flux) entre différents flux de manière transparente. Bien que vous puissiez le faire avec des rappels, si vous essayez d'implémenter un cas d'utilisation plus compliqué, qui peut même être aussi simple que 3 requêtes, le code perdra très rapidement sa lisibilité. D'autre part, Rx vous permet d'implémenter des scénarios très complexes tout en conservant une apparence lisse.
  • Threading et opérations asynchrones

    • Rx vous donne un contrôle très granulaire sur les threads qui seront utilisés pour effectuer le travail à divers points dans un flux. Pour souligner déjà le contraste, l'approche d'appel de base utilisée dans Retrofit consiste uniquement à planifier le travail sur ses threads de travail et à renvoyer le résultat dans le thread appelant. Une fois déclaré en tant que flux, retrofit ne gère pas le threading et ne vous le laisse que pour vous donner le contrôle.
  • Bibliothèques Rx

    • Comme vous l'avez peut-être déjà vu, il existe d'innombrables bibliothèques qui exploitent les extensions Reactive et implémentent diverses fonctionnalités en tant que flux. Vous pouvez facilement en tirer parti lorsque vous travaillez avec vos demandes

Il y a d'autres avantages à côté de ceux-ci, mais vous pouvez dire qu'il est très bénéfique d'être réactif. Les requêtes sont un très bon point de départ pour apprendre à travailler avec des flux et introduisent progressivement de plus en plus de logique de flux dans votre code.

Ce n'est pas une substitution. RxJava et Retrofit conviennent parfaitement, c'est pourquoi il existe un support natif pour cela dans Retrofit en premier lieu.


Question

Retrofit Déjà en cours d'exécution sur le fil de fond. Alors pourquoi avoir besoin d’une autre tâche d’arrière-plan, RxJava?

Je pense surtout, éviter les rappels imbriqués ( callback hell ).

par exemple) enfer de rappel (Retrofit)

public interface MyService
{
    @GET("users")
    Call<List<UserModel>> getUser();

    @GET("userinfo")
    Call<UserInfoModel> getUserInfoById(@Query("id") Integer id);
}

service.getUser().enqueue(new Callback<UserModel>() {

    @Override
    public void onResponse(Call<UserModel> call, Response<UserModel> response) {
        //process UserModel

        UserModel data = response.body();

        //if you want user infomation from server
        service.getUserInfo(data.getId()).enqueue(new Callback<UserInfoModel>(){
            //... is callback hell!!
        });

    }
    @Override
    public void onFailure(Call<UserModel> call, Throwable t) {
       //error handling
    }
});

p.ex.) Évitez les rappels (Retrofit + RxJava)

public interface MyService
{
    @GET("users")
    Observable<List<UserModel>> getUser();

    @GET("userinfo")
    Observable<UserInfoModel> getUserInfoById(@Query("id") Integer id);
}

service.getUser()
    .flatMapIterable(list -> list)
    .flatMap(user -> service.getUserInfoById(user.getId()))
    .doOnNext(userinfo -> saveUserInfo(userinfo)).subscribe();

Si vous utilisez RxJava vous pouvez utiliser Observable pour éviter cette situation.

Additionnel

L'extrait de code ci-dessus n'est qu'un exemple.

En fait, RxJava contient beaucoup plus de fonctionnalités liées au observe pattern .

Supplémentaire - Avantage de la programmation événementielle sous Android (RxJava)

La plupart Android application sont construites avec des interaction utilisateur ou données. (par exemple, l'interface graphique est mise à jour lorsque l'interaction se produit). Nous les considérons donc comme un set of events . Concevoir et construire une application à partir de cela est très intuitif et convient aux événements internes et externes.





retrofit2