PricingLoginStart free
Kotlin Academy · Leçon

catch et onCompletion : gestion des erreurs dans Flow

Interceptez les exceptions en amont et réagissez aux événements de fin du flux.

Leçon 2 sur 413 étapes

catch et onCompletion : gestion des erreurs dans Flow est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Bases des exceptions dans les flux

Les exceptions dans un flux l'arrêtent. Sans gestion appropriée, l'exception se propage jusqu'au collecteur et le flux s'arrête.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    try {
        flow {
            emit(1)
            throw RuntimeException("stream error")
            emit(2)
        }.collect { println(it) }
    } catch (e: Exception) {
        println("Caught: ${e.message}")
    }
}

Opérateur de gestion des erreurs

catch gère les exceptions en amont et peut émettre des valeurs de remplacement ou relancer l'exception. Il ne capture pas les exceptions levées par le collecteur lui-même.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flow {
        emit(1)
        throw RuntimeException("oops")
    }.catch { e ->
        println("Caught: ${e.message}")
        emit(-1)  // fallback value
    }.collect { println(it) } // 1, then -1
}

La gestion ne concerne que l'amont

catch intercepte uniquement les exceptions du générateur de flux et des opérateurs en amont — pas celles de la fonction lambda de collect.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    try {
        flowOf(1, 2, 3)
            .catch { e -> println("upstream: ${e.message}") }
            .collect {
                if (it == 2) throw RuntimeException("collector error") // not caught by catch
                println(it)
            }
    } catch (e: Exception) {
        println("Collector exception: ${e.message}")
    }
}

Relancer une exception lors de sa gestion

Vous pouvez examiner l'exception et relancer sélectivement celles que vous ne pouvez pas gérer.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    try {
        flow {
            emit(1)
            throw IllegalStateException("state error")
        }.catch { e ->
            if (e is RuntimeException) { emit(-1); return@catch }
            throw e  // rethrow unknown exceptions
        }.collect { println(it) }
    } catch (e: Exception) {
        println("Rethrown: ${e.message}")
    }
}

Opérateur onCompletion

onCompletion s'exécute lorsque le flux s'achève — normalement ou avec une exception. Son paramètre cause n'est pas nul en cas d'échec.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flowOf(1, 2, 3)
        .onCompletion { cause ->
            if (cause == null) println("Completed normally")
            else println("Failed: ${cause.message}")
        }
        .collect { println(it) }
}

onCompletion en cas d'erreur

onCompletion se déclenche même lorsqu'une exception survient en amont. Il reçoit l'exception dans cause, mais ne la supprime pas — l'exception continue de se propager.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    try {
        flow {
            emit(1)
            throw RuntimeException("error")
        }.onCompletion { cause ->
            println("onCompletion cause=${cause?.message}")
        }.collect { println(it) }
    } catch (e: Exception) {
        println("outer catch: ${e.message}")
    }
}

Associer catch et onCompletion

Utilisez catch pour récupérer l'erreur et émettre des valeurs de remplacement, puis onCompletion pour journaliser ou libérer les ressources quel que soit le résultat.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flow {
        emit("ok")
        throw RuntimeException("network error")
    }.catch { e ->
        emit("fallback") // recover
    }.onCompletion {
        println("Stream done — release resources")
    }.collect { println(it) }
}

Opérateur retry

retry(n) { ... } se réabonne au flux en amont en cas d'exception, au maximum n fois.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
var attempt = 0
fun unstableFlow() = flow {
    attempt++
    if (attempt < 3) throw RuntimeException("attempt $attempt failed")
    emit("success on attempt $attempt")
}
fun main() = runBlocking {
    unstableFlow()
        .retry(3) { e -> println("retrying: ${e.message}"); true }
        .collect { println(it) }
}

retryWhen pour une logique personnalisée

retryWhen fournit l'exception et le nombre de tentatives afin que vous puissiez ajouter un délai progressif ou filtrer les exceptions qui déclenchent une nouvelle tentative.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    var n = 0
    flow {
        if (n++ < 2) throw IOException("IO error")
        emit("done")
    }.retryWhen { cause, attempt ->
        cause is IOException && attempt < 3
    }.collect { println(it) }
}

Opérateur onStart

onStart s'exécute avant la première émission — ce qui est utile pour afficher des états de chargement ou initialiser des ressources avant l'arrivée des données.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flowOf("data")
        .onStart { emit("Loading...") }
        .onCompletion { emit("Done") }
        .collect { println(it) }
}

Gestion des erreurs lors d'appels d'API réels

Entourez les flux du dépôt avec catch pour convertir les exceptions en erreurs de domaine, et avec onCompletion pour masquer les indicateurs de chargement.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
sealed class State { object Loading : State(); data class Data(val v: String) : State(); data class Error(val msg: String) : State() }
fun apiFlow(): Flow<String> = flow { delay(50); emit("response") }
fun uiFlow(): Flow<State> = apiFlow()
    .map { State.Data(it) as State }
    .onStart { emit(State.Loading) }
    .catch { e -> emit(State.Error(e.message ?: "unknown")) }
fun main() = runBlocking { uiFlow().collect { println(it) } }

Vérification rapide

Quelle est la principale limite de l’opérateur catch ?

Réponds-y dans la leçon interactive

Récapitulatif

Interception gère les exceptions en amont et peut émettre des valeurs de repli. onCompletion s’exécute toujours (en cas de réussite comme d’erreur) pour effectuer le nettoyage ou la journalisation. Combinez-les avec réessai/retryWhen pour obtenir des chaînes de flux robustes.

Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
51
Leçons
203
Commencer gratuitementVoir le cours complet

Questions Fréquemment Posées

La leçon « catch et onCompletion : gestion des erreurs dans Flow » est-elle gratuite ?

Oui — le texte complet de « catch et onCompletion : gestion des erreurs dans Flow » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « catch et onCompletion : gestion des erreurs dans Flow » ?

Interceptez les exceptions en amont et réagissez aux événements de fin du flux. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « catch et onCompletion : gestion des erreurs dans Flow » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Opérateurs de Flow : map, filter, transform et take
  2. catch et onCompletion : gestion des erreurs dans Flow
  3. combine et zip : fusionner plusieurs Flows
  4. flowOn et buffer : contexte et contre-pression
← Retour à Kotlin Academy