Concept de flux dans Kotlin

Dans Kotlin, les coroutines peuvent être utilisées pour simplifier les codes asynchrones.

Coroutine aide essentiellement à implémenter du code asynchrone et non bloquant. Pour cela, nous utilisons la fonction suspend. Mais le problème avec la fonction suspend est qu’elle renvoie un seul objet. jeDans un tel scénario où vous avez besoin d’un flux de données, Kotlin a le concept de canal et de flux.

Comprenons d’abord la chaîne –

Les API de streaming sont presque l’exact opposé des API REST. Lorsque vous communiquez avec une API REST, vous faites une demande et l’API envoie une réponse. Une API de streaming fonctionne différemment. Il se connecte à un client et écoute en permanence de nouvelles informations au fil du temps. Twitter, par exemple, fournit une API de streaming que vous pouvez utiliser pour diffuser des tweets en temps réel.

Vous pouvez utiliser Sequences pour les flux synchrones. Mais vous avez besoin d’une solution différente pour les flux asynchrones.

Pour les flux asynchrones, vous pouvez utiliser Channels de Kotlin Coroutines. Conceptuellement, vous pouvez considérer les canaux comme des tuyaux. Vous envoyez des éléments via un canal et recevez une réponse via l’autre. Cependant, un canal représente un chaud flux de valeurs. Encore une fois, les flux chauds commencent à produire des valeurs immédiatement.

Coroutine a introduit Flow API pour gérer un flux de données qui émet des valeurs de manière séquentielle.

Ffaible est un type qui peut émettre plusieurs valeurs séquentiellement, alors que suspendre les fonctions qui ne renvoient qu’une seule valeur.

• Eles données transmises doivent être du même type.
• Les données sont émises séquentiellement.
• Peut utiliser un flux pour recevoir des flux de données en direct.

Voyons comment Flow fonctionne dans Kotlin :

Le flux Kotlin est en fait un mécanisme de thread. Cela est principalement dû au flux de données qui peut en toute sécurité demander au réseau de produire la valeur suivante sans bloquer le fil de programmation principal. Il est essentiellement suivi à travers trois types d’entités impliquées dans les flux de données.

Nous pouvons créer les flux à l’aide des API de création de flux et de la fonction appelée flux pour créer manuellement et émettre les nouvelles valeurs dans le flux de données à l’aide de la fonction d’émission. Fondamentalement, la source de données récupère les données automatiquement à intervalle fixe lorsque la fonction de suspension qui ne peut pas renvoyer plusieurs valeurs consécutives crée et renvoie le flux pour répondre à l’exigence. Parfois, la source de données agira en tant que producteur, de sorte que le générateur de flux est exécuté dans la coroutine et bénéficiera donc des mêmes API asynchrones, mais certaines restrictions doivent être appliquées.

Les flux sont séquentiels car le producteur est de type coroutine ; lors de l’appel de la fonction de suspension, le producteur suspend jusqu’à ce que la fonction de suspension renvoie la valeur. Le producteur suspend jusqu’à ce que les requêtes réseau soient terminées, le résultat est donc émis dans le flux. De plus, parfois en utilisant le générateur de flux, le producteur ne peut pas émettre les valeurs des différents contextes Coroutine.

Créons un flux en utilisant couler opérateur:

Nous devons créer un producteur pour produire de la valeur

fun producer(): Flow<Int> = flow {

   val list = listOf(1,2,3,4,5,6,7,8,9)

   list.forEach{

       delay(1000)

       emit(it)

   }

}

Pour consommer le producteur, nous utilisons la méthode de collecte.

GlobalScope.launch {

   val data  = producer()

   data.collect{

       Log.d("Value ",it.toString())

   }

}

Pourquoi utiliser Kotlin Flow –

Il existe déjà d’autres implémentations de la spécification de flux réactif, telles que RxJava. Alors pourquoi utiliser Kotlin Flow ? L’une des raisons est que vous ne pouvez pas utiliser de bibliothèques spécifiques à la JVM telles que RxJava dans les projets multiplateformes Kotlin. Mais Flow fait partie du langage Kotlin, il est donc idéal à utiliser dans les projets multiplateformes Kotlin.

De plus, Kotlin Flow a moins d’opérateurs, mais ils sont beaucoup plus simples. Un seul opérateur peut gérer à la fois la logique synchrone et asynchrone puisque le bloc de code accepté par les opérateurs peut être suspendu !

Et Kotlin Flow est interopérable avec d’autres flux réactifs et coroutines. Puisqu’il est construit sur des coroutines, il offre tous les avantages de la simultanéité et de l’annulation structurées. En combinaison avec des fonctions de suspension, il produit une API simple, lisible et compréhensible. Il prend également en charge la contre-pression hors de la boîte.

Ce blog a enseigné ce qui est si spécial à propos de Kotlin Flow et en quoi il diffère des solutions existantes. J’espère que vous avez apprécié ce blog !

Bon codage !

TROUVÉ CELA UTILE ? PARTAGEZ-LE