Scala for Backend Engineering & Functional Programming · Ders

Future İçinde Hata İşleme

Eşzamansız `Gelecek` hesaplamalarında özel durumları ve başarısızlıkları düzgün biçimde ele alma stratejileri uygulayın.

Future İçinde Hata İşleme, CoddyKit'te ücretsiz bir Scala for Backend Engineering & Functional Programming dersidir. Bu, 3 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Scala for Backend Engineering & Functional Programming öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Scala for Backend Engineering & Functional Programming kursu toplamda 3 dersten oluşur.

Future hatalarını ele alma

Eşzamansız işlemler başarısız olabilir! Eşzamanlı kodun istisnalar fırlatabilmesi gibi, bir Future da başarılı bir değer yerine hatayla tamamlanabilir.

Bu hataları düzgün bir şekilde ele almayı anlamak, sağlam eşzamanlı uygulamalar oluşturmak için çok önemlidir. Uygun hata işleme olmadan programınız çökebilir veya beklenmedik şekilde davranabilir.

Future sonucu: Try

Bir Future tamamlandığında sonucu bir scala.util.Try içinde sarılır. Bu Try, Success(value) veya Failure(exception) olabilir.

Success: Hesaplanan değeri içerir.
Failure: Oluşan istisnayı içerir.

onComplete geri çağırması bu Try nesnesini alır; böylece her iki sonucu da ele alabilirsiniz.

Hatalar için onComplete kullanımı

onComplete yöntemi, bir Future'ın tamamlanmasını dinleyen genel amaçlı bir dinleyicidir. Try[T] kabul eden bir işlev alır.

Başarı ile başarısızlığı ayırt etmek için Try üzerinde örüntü eşleştirmesi yapabilirsiniz.

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

recover yöntemi

recover, bir istisnayı ele almanıza ve Future başarısız olursa kullanılacak yedek bir değer sağlamanıza olanak tanır. Bir Future[T]'ı başka bir Future[T]'a dönüştürür.

İlk Future başarısız olursa sağlanan kısmi işlev istisnaya uygulanır. Eşleşme varsa yedek değeri içeren yeni ve başarılı bir Future döndürülür.

recover örneği

Burada sıfıra bölme gerçekleşirse recover, ArithmeticException'ı yakalar ve 0 değerini içeren bir Future döndürür.

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

recoverWith yöntemi

recoverWith, recover'a benzer; ancak yedek bir değer döndürmek yerine yedek bir Future döndürür.

Kurtarma işleminizin kendisi başka bir eşzamansız işlem içerdiğinde veya ilk işlemi yeniden denemek istediğinizde kullanışlıdır.

recoverWith örneği

İlk Future başarısız olursa recoverWith, farklı bir işlemi veya varsayılan bir eşzamansız değeri deneyen yeni bir future sağlar.

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

fallbackTo yöntemi

fallbackTo, iki Future'ı zincirlemenize olanak tanır. İlk Future başarısız olursa sonucu yok sayılır ve bunun yerine ikinci Future'ın sonucu kullanılır.

recoverWith'den farklı olarak fallbackTo istisnayı incelemez. Yalnızca şunu söyler: "Bu başarısız olursa şunu dene."

fallbackTo örneği

Burada failingFuture başarısız olursa fallbackTo, backupFuture'ın sonucunu kullanır.

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

Hata işleme testi

Bir Future başarısız olduğunda alternatif bir eşzamansız işlem sağlamak istiyorsanız hangi yöntemi kullanırsınız?

Özet: Future hata işleme

Scala Future'larındaki hataları ele almak için temel stratejileri inceledik:

onComplete: Bir Try ile hem başarıya hem de başarısızlığa tepki verir.
recover: Bir istisna oluştuğunda yedek bir değer sağlar.
recoverWith: Bir istisna oluştuğunda yedek bir Future sağlar.
fallbackTo: Birincil Future başarısız olursa hatayı incelemeden yedek bir Future kullanır.

Bu yöntemler dayanıklı eşzamansız sistemler oluşturmak için gereklidir!

Sıkça Sorulan Sorular

“Future İçinde Hata İşleme” dersi ücretsiz mi?

Evet — “Future İçinde Hata İşleme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Scala for Backend Engineering & Functional Programming kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Scala for Backend Engineering & Functional Programming kursu toplamda 3 dersten oluşur.

“Future İçinde Hata İşleme” dersinde ne öğreneceğim?

Eşzamansız `Gelecek` hesaplamalarında özel durumları ve başarısızlıkları düzgün biçimde ele alma stratejileri uygulayın. Scala for Backend Engineering & Functional Programming ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Scala for Backend Engineering & Functional Programming öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Scala for Backend Engineering & Functional Programming, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 3 dersinin 3. dersidir.

“Future İçinde Hata İşleme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Scala for Backend Engineering & Functional Programming dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Scala for Backend Engineering & Functional Programming dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Scala for Backend Engineering & Functional Programming Sayfasına Dön