Scala for Backend Engineering & Functional Programming · Pelajaran

Penanganan Galat dalam Future

Terapkan strategi untuk menangani pengecualian dan kegagalan dengan baik dalam komputasi `Future` asinkron.

Penanganan Galat dalam Future adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 3 dari 3. 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 Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Menangani Kegagalan Future

Operasi asinkron dapat gagal! Sama seperti kode sinkron yang dapat melempar pengecualian, sebuah Future dapat selesai dengan kesalahan, bukan dengan nilai sukses.

Memahami cara menangani kegagalan ini dengan baik sangat penting untuk membangun aplikasi konkuren yang tangguh. Tanpa penanganan kesalahan yang tepat, program Anda mungkin berhenti atau berperilaku tidak terduga.

Hasil Future: Try

Ketika sebuah Future selesai, hasilnya dibungkus dalam scala.util.Try. Try ini dapat berupa Success(value) atau Failure(exception).

Success: Berisi nilai yang dihitung.
Failure: Berisi pengecualian yang terjadi.

Panggilan balik onComplete menerima objek Try ini, sehingga Anda dapat menangani kedua kemungkinan hasil.

Menggunakan onComplete untuk Kesalahan

Metode onComplete adalah pendengar umum untuk penyelesaian sebuah Future. Metode ini menerima fungsi yang menerima Try[T].

Anda dapat mencocokkan pola pada Try untuk membedakan keberhasilan dan kegagalan.

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Success, Failure}

object Main {
  def main(args: Array[String]): Unit = {
    val failingFuture = Future { 
      if (true) throw new RuntimeException("Oops!")
      10
    }

    failingFuture.onComplete {
      case Success(value) => println(s"Success: $value")
      case Failure(exception) => println(s"Failure: ${exception.getMessage}")
    }

    Thread.sleep(100) // Keep JVM alive for Future to complete
  }
}

Metode recover

recover memungkinkan Anda menangani pengecualian dan menyediakan nilai pengganti jika Future gagal. Metode ini mengubah Future[T] menjadi Future[T] lain.

Jika Future awal gagal, fungsi parsial yang diberikan diterapkan pada pengecualian tersebut. Jika cocok, Future baru yang berhasil dan berisi nilai pengganti akan dikembalikan.

Contoh recover

Di sini, jika pembagian dengan nol terjadi, recover menangkap ArithmeticException dan mengembalikan Future dengan nilai 0.

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

object Main {
  def main(args: Array[String]): Unit = {
    val resultFuture = Future { 10 / 0 } // This will fail

    val recoveredFuture = resultFuture.recover {
      case e: ArithmeticException =>
        println("Caught ArithmeticException, recovering...")
        0 // Fallback value
    }

    recoveredFuture.foreach(value => println(s"Result: $value"))

    Thread.sleep(100) // Keep JVM alive
  }
}

Metode recoverWith

recoverWith mirip dengan recover, tetapi alih-alih mengembalikan nilai pengganti, metode ini mengembalikan Future pengganti.

Metode ini berguna ketika tindakan pemulihan itu sendiri melibatkan operasi asinkron lain, atau ketika Anda ingin mencoba kembali operasi awal.

Contoh recoverWith

Jika Future awal gagal, recoverWith menyediakan Future baru yang mencoba operasi lain atau nilai asinkron bawaan.

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

object Main {
  def main(args: Array[String]): Unit = {
    val primaryOperation = Future { 
      if (true) throw new Exception("Primary failed!")
      100
    }

    val fallbackOperation = Future { 
      println("Running fallback operation...")
      50 
    }

    val finalFuture = primaryOperation.recoverWith {
      case e: Exception =>
        println(s"Primary failed: ${e.getMessage}. Using fallback.")
        fallbackOperation
    }

    finalFuture.foreach(value => println(s"Final result: $value"))

    Thread.sleep(200) // Keep JVM alive
  }
}

Metode fallbackTo

fallbackTo memungkinkan Anda merangkai dua Future. Jika Future pertama gagal, hasilnya diabaikan dan hasil dari Future kedua digunakan sebagai gantinya.

Berbeda dari recoverWith, fallbackTo tidak memeriksa pengecualian. Metode ini hanya menyatakan: "Jika yang ini gagal, coba yang itu."

Contoh fallbackTo

Di sini, jika failingFuture gagal, fallbackTo akan menggunakan hasil dari backupFuture.

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

object Main {
  def main(args: Array[String]): Unit = {
    val failingFuture = Future { 
      if (true) throw new RuntimeException("Network error!")
      "Data from primary"
    }

    val backupFuture = Future { 
      println("Using backup source...")
      "Data from cache"
    }

    val finalResult = failingFuture.fallbackTo(backupFuture)

    finalResult.foreach(value => println(s"Retrieved: $value"))

    Thread.sleep(100) // Keep JVM alive
  }
}

Kuis Penanganan Kesalahan

Metode mana yang akan Anda gunakan jika ingin menyediakan operasi asinkron alternatif ketika sebuah Future gagal?

Ringkasan: Penanganan Kesalahan Future

Kita telah mempelajari strategi utama untuk menangani kesalahan dalam Future Scala:

onComplete: Merespons keberhasilan dan kegagalan dengan Try.
recover: Menyediakan nilai pengganti jika terjadi pengecualian.
recoverWith: Menyediakan Future pengganti jika terjadi pengecualian.
fallbackTo: Menggunakan Future cadangan jika yang utama gagal, tanpa memeriksa kesalahannya.

Metode-metode ini penting untuk membangun sistem asinkron yang tangguh!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penanganan Galat dalam Future” gratis?

Ya — teks lengkap “Penanganan Galat dalam Future” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Penanganan Galat dalam Future”?

Terapkan strategi untuk menangani pengecualian dan kegagalan dengan baik dalam komputasi `Future` asinkron. Kamu berlatih Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming 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 3 dari 3.

Berapa lama pelajaran “Penanganan Galat dalam Future” 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 Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming 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

← Kembali ke Scala for Backend Engineering & Functional Programming