Dans cet article, je vais expliquer les bases de RxJava à travers des exemples. Cet article est destiné aux débutants en RxJava. D’autre part, si vous savez déjà quelque chose sur RxJava, cet article est bon pour réviser vos connaissances.

RxJava est une implémentation Java VM de ReactiveX une bibliothèque pour composer des programmes asynchrones et basés sur des événements en utilisant des séquences observables.

Les blocs de construction de RxJava sont les Observables et les Subscribers. Observable est utilisé pour émettre des éléments et Subscriber est utilisé pour consommer ces éléments. Peut-être que certains d’entre vous penseront : « Hmmm c’est tellement similaire au pattern Observable standard ». Et oui, c’est le cas, mais RxJava le fait beaucoup mieux et offre plus d’options. Par exemple, les Observables ne commencent souvent pas à émettre des éléments avant que quelqu’un ne s’y abonne. C’est une excellente fonctionnalité car de cette façon, vous devriez économiser vos performances.

RxJava fonctionne comme suit . L’abonné s’abonne à Observable, puis Observable appelle Subscriber.onNext() pour un nombre quelconque d’éléments, si quelque chose ne va pas, voici Subsciber.onError() et si tout se termine bien, voici Subscriber.onCompleted(). Vous voyez, c’est facile!

Taisez-vous ! Donnez-moi des codes fantaisistes !

Exemple 1

Dans cet exemple, nous allons créer un Observable et un Subscriber de base, puis nous les relierons, et nous verrons ce qui se passera. Alerte spoiler ! Quelque chose d’impressionnant…

Créons un Observable de base:

L’Observable créé émet la Chaîne « Blue Factory » et se termine. La chaîne « Blue Factory » sera reçue par la méthode onNext() de Subscriber. Maintenant, créons Subscriber.

Subscriber reçoit la valeur String onNext() method et l’imprime, aussi String « I’m done » s’imprime quand on appelle onCompleted() methods.

Maintenant, reliez-les entre eux.

Résultat:

I/System.out : Usine bleue

I/System.out : J’ai fini

Lorsque la souscription se produit, myObservable appelle les méthodes mySubscription onNext() et onComplited(). Les résultats sont les sorties « Blue factory » et « I’m done », après quoi tout s’arrête et se termine.

Peut-on faire plus simple ?

Bien sûr ! Vous pouvez le faire!

Vous pouvez remarquer qu’une création de myObservable a trop de code et que cela semble désordonné. RxJava nous donne quelques raccourcis fantaisistes.

Certains de ces raccourcis sont des méthodes comme Observable.just() et Observable.from();

Observable.just() n’émet qu’un seul élément et Observable.from() émet un élément par un à partir d’une liste d’éléments.

Taisez-vous ! Donnez-moi du code fantaisiste !

Exemple 2

Dans cet exemple, nous allons faire la même chose que dans l’exemple 1, mais maintenant avec moins de code.

Créons notre nouvel Observable fantaisiste et beau :

Wow ! Il semble que notre Observable ait perdu du poids!
Créons l’Abonné:

L’Abonné est le même !
Maintenant, reliez-les et attendez que la magie opère !

Résultat:

I/System.out : Usine bleue
I/System.out : J’ai fini

Comme vous le voyez, nous parvenons à accomplir notre tâche, et à faire exactement la même chose avec moins de code.
Taisez-vous ! Donnez-moi du code fantaisiste !

Exemple 3

Dans cet exemple, nous allons faire quelque chose de légèrement différent avec Observable.from(). L’idée est d’imprimer les chaînes de caractères « Blue », « Factory », « Blog », « Post ».
Rappelons ce qu’est Observable.from(). Observable.from() reçoit la liste des éléments et émet sur élément par élément, donc Observable.from() est exactement ce dont nous avons besoin !
D’abord nous allons créer ArrayList avec des chaînes de caractères :

Créons cet Observable.from(), d’accord ?

Comme vous pouvez le voir, Observable.from() reçoit comme argument ArrayList chargé de Strings. Maintenant, créons un Subscriber et relions-les, et attendons la magie.

Résultat:

I/System.out : Blue
I/System.out : Factory
I/System.out : Blog
I/System.out : Post

Comme vous le voyez, nous avons à nouveau réussi notre tâche !
Tout ce que vous avez appris jusqu’à présent sont des astuces de base pures, mais maintenant nous allons faire des astuces plus « difficiles » !

Que sont les opérateurs dans Rx ?

Les opérateurs sont des méthodes créées pour résoudre les transformations et gérer les problèmes d’appels d’API. Je vais vous montrer un exemple simple pour la transformation avec Map, et peut-être dans d’autres articles des exemples de gestion des appels API avec Retrofit, RxJava sur le modèle architectural MVP.

Par exemple ajoutons notre chaîne « Blue Factory » avec  » Blog Post ». Nous pouvons le faire de plusieurs façons.

Première façon:

Nous pouvons le faire dans Observable, mais Observable est censé émettre des éléments, pas les changer.
Deuxième façon:

Même histoire, Subscriber n’était pas censé changer les items.
La solution est d’ajouter une étape supplémentaire, en ajoutant Operator. Operator est une étape supplémentaire entre Observable et Subscriber, où l’objet peut être transformé.
Alors faisons-le de la bonne manière !
Shut up ! Donnez-moi du code fantaisiste !

Exemple 4

Créons d’abord l’Observable :

Notez que monObservable n’émet qu’un seul élément inchangé.
Créons maintenant l’Opérateur, pour cet exemple la meilleure solution est d’utiliser l’opérateur Map. L’opérateur Map peut transformer notre objet de la manière qui nous convient et le renvoyer à l’Abonné.

Dans l’appel des opérateurs (String s) la transformation de la méthode String « Blue Factory » est faite.
Et voici Subscriber:

Résultat:

I/System.out : Blue Factory Blog Post

Cet exemple représente une minuscule fraction de ce que les opérateurs peuvent faire. Par exemple, l’opérateur Map peut être empilé plusieurs fois comme dans l’exemple ci-dessous:
Shut up ! Donnez-moi du code fantaisiste!

Exemple 5

Les opérateurs peuvent également changer le type d’élément émis comme dans l’exemple ci-dessous:
Shut up ! Donnez-moi du code fantaisiste !

Exemple 6

Dans cet exemple, l’Observable émettra la chaîne « 5 » et l’Opérateur la transformera en nombre entier 5. Créons Observable.

Notez que le type myObservable est Observable et Observable émet String.
Créons l’opérateur Map!

Notez que la méthode Map operator call(String s) reçoit String et retourne Integer.
Créons Subscriber et relions-les.

Le type Subscriber est le même que le type Observable, et le type de retour Operators (Integer).
Je vous montre ici juste une petite fraction de l’image. Avec les opérateurs, vous pouvez faire tout ce que vous voulez ! Et la meilleure partie à ce sujet est que RxJava a une abondance de différents opérateurs. Ici vous pouvez vérifier tous les opérateurs : https://github.com/ReactiveX/RxJava/wiki/Alphabetical-List-of-Observable-Operators.

En conclusion Les opérateurs sont puissants pour la transformation des objets et le polissage des données, et après tout cela, votre code aura l’air beau et propre !

Que puis-je faire avec RXJava ?

Vous pouvez faire tout ce que vous voulez car votre Observable peut être tout, il peut être : Une chaîne de caractères, un nombre entier, un appel d’API, un clic, etc. Au fur et à mesure que vous progressez comme développeur Android, vous utiliserez RxJava principalement pour les appels API et pour les widgets android. RxJava permet de gérer facilement les API, car vous n’avez pas à vous soucier du threading et vous pouvez enchaîner plusieurs requêtes et obtenir le résultat sur un seul abonné. Avec RxJava, vous pouvez gérer le comportement de certains widgets, par exemple ce que fera le widget après cinq pressions, ou vous pouvez créer un Observable qui émettra une chaîne toutes les 4 secondes à partir de l’entrée EditText, et bien d’autres choses encore. J’espère que cet article vous donne les bases de RxJava et j’espère que vous continuerez à explorer RxJava dans le futur.