Fehler- und Abhängigkeitskanäle
Typisierte Fehler und Umgebung
Fehler- und Abhängigkeitskanäle ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Zwei leistungsfähige Kanäle
Neben dem Erfolgswert verfolgt ZIO[R, E, A] einen typisierten Fehlerkanal E und einen Abhängigkeitskanal R. Beide sind im Typ sichtbar, sodass Fehler und Anforderungen bereits zur Compile-Zeit explizit sind.
Typisierte Fehler
Modellieren Sie Domänenfehler als versiegelte Hierarchie und legen Sie sie in E ab. Der Compiler zwingt Sie dann, genau diese Fälle zu behandeln.
import zio._
sealed trait AppError
case object NotFound extends AppError
case object Forbidden extends AppError
val lookup: IO[AppError, String] = ZIO.fail(NotFound)Fehlerbehandlung mit catchAll
catchAll behandelt jeden Fehler in E, indem es einen neuen Effekt bereitstellt. Danach kann der Fehlerkanal zu Nothing werden, wenn alle Fehler behandelt wurden.
import zio._
val safe: UIO[String] =
ZIO.fail("boom").catchAll(e => ZIO.succeed(s"recovered: $e"))catchSome und orElse
catchSome behandelt nur passende Fehler. orElse greift bei jedem Fehler auf einen anderen Effekt zurück.
import zio._
val prog = ZIO.fail("x").orElse(ZIO.succeed("fallback"))Either und fold
either wandelt ZIO[R, E, A] in ZIO[R, Nothing, Either[E, A]] um. fold verarbeitet Fehler und Erfolg zu einem gemeinsamen Wert.
import zio._
val label: UIO[String] =
ZIO.fail(404).fold(e => s"err $e", v => s"ok $v")Defects und Fehler
ZIO unterscheidet Fehler (typisiert, erwartet, in E) von Defects (unerwarteten Throwables). ZIO.die löst einen Defect aus. Defects sind nicht im Typ E enthalten und stellen Programmfehler dar.
Die Umgebung R
Der Kanal R gibt die Dienste an, die ein Effekt benötigt. Greifen Sie mit ZIO.service auf einen Dienst zu; die Anforderung bleibt in R, bis sie bereitgestellt wird.
import zio._
trait Logger { def log(s: String): UIO[Unit] }
val prog: ZIO[Logger, Nothing, Unit] =
ZIO.serviceWithZIO[Logger](_.log("hello"))Einen Dienst definieren
Ein Dienst besteht aus einem Trait und einer ZLayer, die ihn erstellt. Layer beschreiben, wie Abhängigkeiten erstellt werden, und können selbst von anderen abhängen.
import zio._
case class ConsoleLogger() extends Logger {
def log(s: String): UIO[Unit] = ZIO.succeed(println(s))
}
object ConsoleLogger {
val layer: ULayer[Logger] = ZLayer.succeed(ConsoleLogger())
}
trait Logger { def log(s: String): UIO[Unit] }Abhängigkeiten bereitstellen
provide (oder provideLayer) erfüllt die Anforderung R und wandelt ZIO[Logger, E, A] in das ausführungsbereite ZIO[Any, E, A] um.
import zio._
val runnable: UIO[Unit] =
ZIO.serviceWithZIO[Logger](_.log("hi"))
.provide(ConsoleLogger.layer)
trait Logger { def log(s: String): UIO[Unit] }
object ConsoleLogger { val layer: ULayer[Logger] = ??? }Layer kombinieren
Layer werden horizontal mit ++ (kombinieren) und vertikal mit >>> (die Ausgabe eines Layers als Eingabe des nächsten verwenden) kombiniert. So entsteht ein vollständiger Abhängigkeitsgraph.
import zio._
// val appLayer = configLayer ++ (dbLayer >>> repoLayer)Ausgangsbasis mit einfachem Scala
Zum Vergleich ein eigenständiges Scala-Programm mit manueller Fehlerbehandlung. ZIO codiert denselben Fehler im Typ und injiziert Abhängigkeiten über Layer.
object Main {
def main(args: Array[String]): Unit = {
val result: Either[String, Int] = Left("NotFound")
val msg = result.fold(e => s"err $e", v => s"ok $v")
println(msg)
}
}Kurze Überprüfung
Was bewirkt die Methode provide bei einem ZIO[Logger, E, A]?
Zusammenfassung
Sie haben mit beiden zusätzlichen Kanälen gearbeitet:
- Fehler: typisiertes
E,catchAll,orElse,fold, Defects im Vergleich zu Fehlern - Abhängigkeiten:
R, Dienste,ZLayer,provide, Layer-Komposition
Als Nächstes: ZIO-Anwendungen ausführen.
Häufig gestellte Fragen
Ist die Lektion „Fehler- und Abhängigkeitskanäle“ kostenlos?
Ja — der vollständige Text von „Fehler- und Abhängigkeitskanäle“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Fehler- und Abhängigkeitskanäle“?
Typisierte Fehler und Umgebung Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?
Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Fehler- und Abhängigkeitskanäle“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?
Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Der ZIO-Effekt
- ZIO kombinieren
- Fehler- und Abhängigkeitskanäle
- ZIO-Apps ausführen