0Pricing
Kotlin Academy · Pelajaran

catch dan onCompletion: Penanganan Error dalam Flow

Tangkap exception dari upstream dan tanggapi peristiwa penyelesaian flow.

catch dan onCompletion: Penanganan Error dalam Flow adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

Dasar-Dasar Pengecualian Aliran

Pengecualian dalam aliran akan menghentikannya. Tanpa penanganan, pengecualian tersebut merambat ke pengumpul dan aliran berakhir.

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}")
    }
}

Operator Penanganan

catch menangani pengecualian dari aliran sumber dan dapat memancarkan nilai cadangan atau melempar ulang. Operator ini tidak menangkap pengecualian yang dilempar oleh pengumpul itu sendiri.

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
}

Operator Penanganan Hanya Menangani Sumber Hulu

catch hanya mencegat pengecualian dari pembangun aliran dan operator hulu—bukan dari lambda 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}")
    }
}

Melempar Ulang saat Menangani

Anda dapat memeriksa pengecualian dan secara selektif melempar ulang pengecualian yang tidak dapat Anda tangani.

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}")
    }
}

Operator onCompletion

onCompletion dijalankan ketika aliran selesai—secara normal atau dengan pengecualian. Parameter cause-nya tidak bernilai null saat terjadi kegagalan.

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 saat Terjadi Kesalahan

onCompletion tetap dijalankan ketika terjadi pengecualian dari aliran sumber. Operator ini menerima pengecualian sebagai cause, tetapi tidak menekannya—pengecualian tersebut tetap merambat.

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}")
    }
}

Menggabungkan Penanganan dan onCompletion

Gunakan catch untuk memulihkan keadaan dan memancarkan nilai cadangan, lalu gunakan onCompletion untuk mencatat atau melepaskan sumber daya apa pun hasilnya.

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) }
}

Operator retry

retry(n) { ... } berlangganan ulang ke aliran sumber saat terjadi pengecualian hingga n kali.

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 untuk Logika Kustom

retryWhen menyediakan pengecualian dan jumlah attempt sehingga Anda dapat menambahkan penundaan bertahap atau menyaring pengecualian mana yang memicu retry.

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) }
}

Operator onStart

onStart dijalankan sebelum pancaran pertama—berguna untuk menampilkan status pemuatan atau menginisialisasi sumber daya sebelum data tiba.

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

Penanganan Kesalahan dalam Panggilan API Nyata

Bungkus alur repositori dengan catch untuk memetakan pengecualian menjadi kesalahan domain dan onCompletion untuk menyembunyikan indikator pemuatan.

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) } }

Pemeriksaan Singkat

Apa keterbatasan utama operator catch?

Ringkasan

tangkap menangani pengecualian dari hulu dan dapat menghasilkan nilai cadangan. onCompletion selalu berjalan, baik saat normal maupun saat terjadi kesalahan, untuk pembersihan atau pencatatan log. Gabungkan keduanya dengan coba lagi/coba lagi saat untuk membuat alur yang tangguh.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “catch dan onCompletion: Penanganan Error dalam Flow” gratis?

Ya — teks lengkap “catch dan onCompletion: Penanganan Error dalam Flow” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kotlin Academy, upgrade ke CoddyKit PRO. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “catch dan onCompletion: Penanganan Error dalam Flow”?

Tangkap exception dari upstream dan tanggapi peristiwa penyelesaian flow. Kamu berlatih Kotlin Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Kotlin Academy?

Tidak diperlukan pengalaman sebelumnya. Kotlin Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “catch dan onCompletion: Penanganan Error dalam Flow” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Operator Flow: map, filter, transform, dan take
  2. catch dan onCompletion: Penanganan Error dalam Flow
  3. combine dan zip: Menggabungkan Beberapa Flow
  4. flowOn dan buffer: Context dan Backpressure
← Kembali ke Kotlin Academy