In Case Classes dekodieren
Ordnen Sie JSON Ihren Typen zu.
In Case Classes dekodieren ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 2 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.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
Decoders Map JSON to Types
A Decoder[A] knows how to read a Json value into a Scala type A.
Circe provides decoders for primitives and collections out of the box, and can build decoders for your own case classes automatically.
A Target Case Class
Suppose your API returns user records. Model the shape with a case class whose field names match the JSON keys.
Matching names is what lets Circe derive a decoder with no manual wiring.
case class User(name: String, age: Int, admin: Boolean)Automatic Derivation
Import io.circe.generic.auto._ and Circe derives a Decoder[User] implicitly, on demand, wherever one is needed.
You then call decode[User] with no extra boilerplate.
import io.circe.generic.auto._
import io.circe.parser.decode
val json = "{\"name\":\"Ada\",\"age\":36,\"admin\":true}"
val user = decode[User](json)
println(user) // Right(User(Ada,36,true))Semi-Automatic Derivation
For better compile times and explicit control, use io.circe.generic.semiauto.deriveDecoder.
You define the decoder once, usually in the companion object, and reuse that single instance everywhere.
import io.circe.Decoder
import io.circe.generic.semiauto._
object User {
implicit val dec: Decoder[User] = deriveDecoder[User]
}Decoding Failures
If a required field is missing or has the wrong type, decoding fails with a DecodingFailure.
The failure carries a history of cursor operations, pinpointing exactly which field caused the problem.
val bad = decode[User]("{\"name\":\"Ada\"}")
println(bad)
// Left(DecodingFailure at .age: Missing required field)Optional Fields in Classes
Make a field Option[A] when the JSON key may be absent or null.
Circe decodes a missing key to None automatically, so you do not need a custom decoder just for optionality.
case class Account(id: Long, nickname: Option[String])
val a = decode[Account]("{\"id\":7}")
println(a) // Right(Account(7,None))Default Values
Case class default values can fill in missing JSON keys, but only when you derive with configured derivation that enables defaults.
The circe-generic-extras module provides this via Configuration.default.withDefaults.
import io.circe.generic.extras._
implicit val cfg: Configuration =
Configuration.default.withDefaults
@ConfiguredJsonCodec
case class Settings(theme: String = "dark")Nested Case Classes
Decoding composes: if Circe can decode each field's type, it can decode a class that nests other case classes.
Derivation recurses automatically, so a single import handles deeply nested structures.
case class Address(city: String)
case class Person(name: String, address: Address)
val p = decode[Person](
"{\"name\":\"Ada\",\"address\":{\"city\":\"London\"}}")
println(p)Renaming Fields
When JSON keys differ from Scala names (for example snake_case), use configured derivation with Configuration.default.withSnakeCaseMemberNames.
This maps created_at to a Scala field createdAt without a hand-written decoder.
import io.circe.generic.extras._
implicit val cfg: Configuration =
Configuration.default.withSnakeCaseMemberNames
@ConfiguredJsonCodec
case class Event(createdAt: String)Accumulating Errors
By default decoding fails fast on the first error. decodeAccumulating instead collects all failures into a ValidatedNel.
This is useful for form validation where you want to report every problem at once.
import io.circe.Decoder
val result = Decoder[User]
.decodeAccumulating(json.hcursor)
// Validated[NonEmptyList[DecodingFailure], User]Choosing a Derivation Style
Use auto for quick prototypes, semiauto for production code where you want fixed instances and faster compiles.
Reach for generic-extras when you need renaming, defaults, or discriminators.
Quick Check
Test your understanding of decoding into case classes.
Recap
A Decoder[A] turns JSON into typed values. Use generic.auto or semiauto.deriveDecoder for case classes whose names match keys.
Missing keys decode Option fields to None; generic-extras adds defaults and renaming; decodeAccumulating gathers all errors.
Häufig gestellte Fragen
Ist die Lektion „In Case Classes dekodieren“ kostenlos?
Ja — der vollständige Text von „In Case Classes dekodieren“ 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 „In Case Classes dekodieren“?
Ordnen Sie JSON Ihren Typen zu. 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 2 von 4.
Wie lange dauert die Lektion „In Case Classes dekodieren“?
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
- JSON parsen
- In Case Classes dekodieren
- Zu JSON kodieren
- Benutzerdefinierte Codecs