Pengendalian Ralat dalam Futures
Laksanakan strategi untuk mengendalikan pengecualian dan kegagalan dengan baik dalam pengiraan `Future` tak segerak.
Pengendalian Ralat dalam Futures ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 3 daripada 3. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 3 pelajaran.
Mengendalikan Kegagalan Future
Operasi tak segerak boleh gagal! Sama seperti kod segerak yang boleh melontarkan pengecualian, sesuatu Future boleh selesai dengan ralat dan bukannya nilai berjaya.
Memahami cara mengendalikan kegagalan ini dengan baik amat penting untuk membina aplikasi serentak yang teguh. Tanpa pengendalian ralat yang betul, atur cara anda mungkin ranap atau berkelakuan di luar jangkaan.
Hasil Future: Try
Apabila sesuatu Future selesai, hasilnya dibungkus dalam scala.util.Try. Try ini boleh berupa Success(value) atau Failure(exception).
- Berjaya: Mengandungi nilai yang dikira.
- Gagal: Mengandungi pengecualian yang berlaku.
Panggilan balik onComplete menerima objek Try ini, lalu membolehkan anda mengendalikan kedua-dua kemungkinan.
Menggunakan onComplete untuk Ralat
Kaedah onComplete ialah pendengar umum untuk penyelesaian sesuatu Future. Kaedah ini mengambil fungsi yang menerima Try[T].
Anda boleh menggunakan pemadanan corak pada Try untuk membezakan antara kejayaan 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
}
}Kaedah recover
recover membolehkan anda mengendalikan pengecualian dan menyediakan nilai sandaran jika Future gagal. Kaedah ini mengubah Future[T] menjadi Future[T] yang lain.
Jika Future asal gagal, fungsi separa yang diberikan akan digunakan pada pengecualian tersebut. Jika sepadan, Future baharu yang berjaya dan mengandungi nilai sandaran akan dikembalikan.
Contoh recover
Di sini, jika pembahagian dengan sifar berlaku, 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
}
}Kaedah recoverWith
recoverWith serupa dengan recover, tetapi bukannya mengembalikan nilai sandaran, kaedah ini mengembalikan Future sandaran.
Kaedah ini berguna apabila tindakan pemulihan itu sendiri melibatkan operasi tak segerak yang lain, atau jika anda mahu mencuba semula operasi asal.
Contoh recoverWith
Jika Future awal gagal, recoverWith menyediakan Future baharu yang cuba menjalankan operasi lain atau nilai tak segerak lalai.
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
}
}Kaedah fallbackTo
fallbackTo membolehkan anda merangkaikan dua Future. Jika Future pertama gagal, hasilnya diabaikan dan hasil Future kedua digunakan sebagai gantinya.
Berbeza daripada recoverWith, fallbackTo tidak memeriksa pengecualian. Kaedah ini hanya menyatakan: "Jika yang ini gagal, cuba yang itu."
Contoh fallbackTo
Di sini, jika failingFuture gagal, fallbackTo akan menggunakan hasil 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
}
}Kuiz Pengendalian Ralat
Kaedah manakah yang akan anda gunakan jika anda mahu menyediakan operasi tak segerak alternatif apabila sesuatu Future gagal?
Imbas Kembali: Pengendalian Ralat Future
Kita telah meneroka strategi utama untuk mengendalikan ralat dalam Future Scala:
onComplete: Bertindak balas terhadap kejayaan dan kegagalan denganTry.recover: Menyediakan nilai sandaran jika pengecualian berlaku.recoverWith: MenyediakanFuturesandaran jika pengecualian berlaku.fallbackTo: MenggunakanFuturesandaran jika yang utama gagal, tanpa memeriksa ralat.
Kaedah-kaedah ini penting untuk membina sistem tak segerak yang berdaya tahan!
Pelajari Scala dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 39
- Pelajaran
- 143
Soalan Lazim
Adakah pelajaran “Pengendalian Ralat dalam Futures” percuma?
Ya — teks penuh “Pengendalian Ralat dalam Futures” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, tingkat taraf kepada CoddyKit PRO. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 3 pelajaran.
Apakah yang akan saya pelajari dalam “Pengendalian Ralat dalam Futures”?
Laksanakan strategi untuk mengendalikan pengecualian dan kegagalan dengan baik dalam pengiraan `Future` tak segerak. Anda berlatih Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 3.
Berapa lamakah pelajaran “Pengendalian Ralat dalam Futures” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian ini?
Ya. Setiap pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Pengenalan kepada Futures dan Promises
- Menggabungkan Operasi Tak Segerak
- Pengendalian Ralat dalam Futures