Mit tud a hibakezelésről a Flow-ban?

A Kotlin Coroutines Flow több hibakezelési módot kínál:

1. catch operátor: Elkapja a kivételeket az emelkedő áramlásban, és lehetővé teszi művelet végrehajtását (pl. naplózás, tartalék adatok visszaadása) vagy az áramlás helyettesítését.

   flow {
       emit(1)
       throw RuntimeException("Hiba történt")
   }.catch { e: Throwable ->
       // Hibakezelés
       emit(-1) // Más érték kibocsátása hiba esetén
   }.collect { value ->
       // Értékek kezelése
   }
   

2. try-catch blokk: Klasszikus módszer kivételek kezelésére kód szakasz körül, beleértve a Flow gyűjtését is.

   try {
       flow {
           emit(1)
           throw RuntimeException("Hiba történt")
       }.collect { value ->
           // Értékek kezelése
       }
   } catch (e: Throwable) {
       // Hiba kezelése
   }
   

   Ez a módszer elkapja a Flow gyűjtése közben fellépő hibákat, de nem azokat, amelyeket a Flow kibocsátója gyűjtés előtt generál.

3. onEach operátor try-catch-el: Ha minden elemhez külön szeretnénk kezelni a hibákat.

   flow {
       emit(1)
       emit(2)
       throw RuntimeException("Hiba 2 után")
       emit(3)
   }.onEach { value ->
       try {
           // Minden elem kezelése
           if (value == 2) throw IllegalArgumentException("Érvénytelen érték 2")
       } catch (e: Throwable) {
           // Hiba kezelése az adott értékhez
           println("Hiba az értéknél $value: ${e.message}")
           // Dobhatjuk tovább a kivételt, ha meg akarjuk állítani a folyamatot
           throw e
       }
   }.catch { e: Throwable ->
       // A nem kezelt hibák vagy az onEach után dobott hibák kezelése
       println("Végső hiba: ${e.message}")
   }.collect { value ->
       println("Gyűjtött érték: $value")
   }
   

4. retry / retryWhen operátorok: Lehetővé teszik az eredeti Flow újrapróbálását hiba esetén.

   • retry: egyszerűen megismétli a próbálkozást a megadott számú alkalommal.
   • retryWhen: feltétel alapján határozza meg, hogy meg kell-e ismételni.

   var attempt = 0
   flow {
       println("Próbálkozás ${++attempt}")
       if (attempt < 3) throw RuntimeException("Újrapróbálás")
       emit(10)
   }.retryWhen { cause, attempt ->
       // Logika a megújítás eldöntéséhez
       cause is RuntimeException && attempt < 3
   }.collect { value ->
       println("Siker: $value")
   }
   

5. Kivétel továbbítása: A nem kezelt hibák felfelé lesznek továbbítva a Flow láncában, és kezelhetők a Flow gyűjtő körül vagy a catch operátorral.

Fontos megérteni, hogy a catch operátor elkapja a hibákat az emelkedő áramlásban (upstream). A hibák, amelyek a lefelé irányuló áramlásban (downstream) keletkeznek a catch után, nem kerülnek elkapásra. Ezek kezeléséhez más catch-t kell használni a láncban vagy try-catch-t a gyűjtő körül.

Általános tanács: a hibakezelést a lehető legközelebb kell helyezni a hiba forrásához, ha ez lehetséges, de figyelembe kell venni, hogy a catch csak az emelkedő áramlást kezeli.