0Pricing
Scala for Backend Engineering & Functional Programming · Lekcja

Kanały błędów i zależności

Typowane błędy i środowisko

Kanały błędów i zależności to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Dwa potężne kanały

Oprócz wartości sukcesu ZIO[R, E, A] śledzi kanał typowanego błędu E oraz kanał zależności R. Oba są widoczne w typie, dzięki czemu niepowodzenia i wymagania są jawne już na etapie kompilacji.

Typowane błędy

Zamodeluj niepowodzenia domenowe jako zapieczętowaną hierarchię i umieść ją w E. Kompilator wymusi wtedy obsługę dokładnie tych przypadków.

import zio._

sealed trait AppError
case object NotFound extends AppError
case object Forbidden extends AppError

val lookup: IO[AppError, String] = ZIO.fail(NotFound)

Odzyskiwanie za pomocą catchAll

catchAll obsługuje każdy błąd w E, dostarczając nowy efekt. Po jego użyciu kanał błędów może stać się Nothing, jeśli wszystkie błędy zostały obsłużone.

import zio._

val safe: UIO[String] =
  ZIO.fail("boom").catchAll(e => ZIO.succeed(s"recovered: $e"))

catchSome i orElse

catchSome odzyskuje działanie tylko po pasujących błędach. orElse używa innego efektu awaryjnego po dowolnym niepowodzeniu.

import zio._

val prog = ZIO.fail("x").orElse(ZIO.succeed("fallback"))

Either i fold

either przekształca ZIO[R, E, A] w ZIO[R, Nothing, Either[E, A]]. fold obsługuje zarówno błąd, jak i sukces, sprowadzając je do jednej wartości.

import zio._

val label: UIO[String] =
  ZIO.fail(404).fold(e => s"err $e", v => s"ok $v")

Defekty a niepowodzenia

ZIO rozróżnia niepowodzenia (typowane, oczekiwane, zawarte w E) od defektów (nieoczekiwanych wyjątków). ZIO.die zgłasza defekt; defekty nie występują w typie E i oznaczają błędy w programie.

Środowisko R

Kanał R deklaruje usługi wymagane przez efekt. Dostęp do usługi uzyskuje się za pomocą ZIO.service; wymaganie pozostaje w R do czasu jego dostarczenia.

import zio._

trait Logger { def log(s: String): UIO[Unit] }

val prog: ZIO[Logger, Nothing, Unit] =
  ZIO.serviceWithZIO[Logger](_.log("hello"))

Definiowanie usługi

Usługa składa się z traitu oraz obiektu ZLayer, który ją tworzy. Warstwy opisują sposób konstruowania zależności i same mogą zależeć od innych warstw.

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

Dostarczanie zależności

provide (lub provideLayer) spełnia wymaganie R, przekształcając ZIO[Logger, E, A] w gotowe do uruchomienia ZIO[Any, E, A].

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] = ??? }

Komponowanie warstw

Warstwy komponuje się poziomo za pomocą ++ (łączenie) i pionowo za pomocą >>> (przekazanie wyjścia jednej warstwy jako wejścia drugiej), budując pełny graf zależności.

import zio._

// val appLayer = configLayer ++ (dbLayer >>> repoLayer)

Podstawowa wersja w Scali

Dla porównania — samodzielny program w Scali z ręczną obsługą błędów. ZIO koduje ten sam błąd w typie i wstrzykuje zależności za pomocą warstw.

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

Szybkie sprawdzenie

Co metoda provide robi z ZIO[Logger, E, A]?

Podsumowanie

Pracowałeś z oboma dodatkowymi kanałami:

  • Błędy: typ E, catchAll, orElse, fold, defekty a niepowodzenia
  • Zależności: R, usługi, ZLayer, provide, komponowanie warstw

Dalej: uruchamianie aplikacji ZIO.

Często zadawane pytania

Czy lekcja „Kanały błędów i zależności” jest bezpłatna?

Tak — pełny tekst „Kanały błędów i zależności” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Co nauczysz się w „Kanały błędów i zależności”?

Typowane błędy i środowisko Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Kanały błędów i zależności”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Efekt ZIO
  2. Komponowanie ZIO
  3. Kanały błędów i zależności
  4. Uruchamianie aplikacji ZIO
← Powrót do Scala for Backend Engineering & Functional Programming