Décoder vers des classes de cas
Associez le JSON à vos types.
Décoder vers des classes de cas est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Les décodeurs associent le JSON aux types
Un Decoder[A] sait lire une valeur Json pour la convertir en type Scala A.
Circe fournit directement des décodeurs pour les types primitifs et les collections, et peut construire automatiquement des décodeurs pour vos propres classes case.
Une classe case cible
Supposons que votre API renvoie des enregistrements utilisateur. Modélisez leur structure avec une classe case dont les noms de champs correspondent aux clés JSON.
Cette correspondance permet à Circe de dériver un décodeur sans câblage manuel.
case class User(name: String, age: Int, admin: Boolean)Dérivation automatique
Importez io.circe.generic.auto._ : Circe dérive implicitement un Decoder[User] à la demande, partout où il est nécessaire.
Vous pouvez ensuite appeler decode[User] sans code répétitif supplémentaire.
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))Dérivation semi-automatique
Pour améliorer les temps de compilation et garder un contrôle explicite, utilisez io.circe.generic.semiauto.deriveDecoder.
Vous définissez le décodeur une seule fois, généralement dans l’objet compagnon, puis réutilisez cette instance unique partout.
import io.circe.Decoder
import io.circe.generic.semiauto._
object User {
implicit val dec: Decoder[User] = deriveDecoder[User]
}Échecs de décodage
Si un champ obligatoire est absent ou possède le mauvais type, le décodage échoue avec un DecodingFailure.
L’échec contient un historique des opérations du curseur, indiquant précisément le champ à l’origine du problème.
val bad = decode[User]("{\"name\":\"Ada\"}")
println(bad)
// Left(DecodingFailure at .age: Missing required field)Champs facultatifs dans les classes
Déclarez un champ en Option[A] lorsque la clé JSON peut être absente ou nulle.
Circe décode automatiquement une clé manquante en None ; vous n’avez donc pas besoin d’un décodeur personnalisé uniquement pour gérer le caractère facultatif.
case class Account(id: Long, nickname: Option[String])
val a = decode[Account]("{\"id\":7}")
println(a) // Right(Account(7,None))Valeurs par défaut
Les valeurs par défaut des classes case peuvent remplir les clés JSON manquantes, mais uniquement lorsque vous utilisez une dérivation configurée qui active les valeurs par défaut.
Le module circe-generic-extras fournit cette fonctionnalité avec Configuration.default.withDefaults.
import io.circe.generic.extras._
implicit val cfg: Configuration =
Configuration.default.withDefaults
@ConfiguredJsonCodec
case class Settings(theme: String = "dark")Classes case imbriquées
Le décodage se compose : si Circe sait décoder le type de chaque champ, il peut décoder une classe qui imbrique d’autres classes case.
La dérivation est automatiquement récursive ; un seul import suffit donc pour gérer des structures profondément imbriquées.
case class Address(city: String)
case class Person(name: String, address: Address)
val p = decode[Person](
"{\"name\":\"Ada\",\"address\":{\"city\":\"London\"}}")
println(p)Renommer des champs
Lorsque les clés JSON diffèrent des noms Scala, par exemple avec snake_case, utilisez une dérivation configurée avec Configuration.default.withSnakeCaseMemberNames.
Cela associe created_at au champ Scala createdAt sans décodeur écrit manuellement.
import io.circe.generic.extras._
implicit val cfg: Configuration =
Configuration.default.withSnakeCaseMemberNames
@ConfiguredJsonCodec
case class Event(createdAt: String)Accumuler les erreurs
Par défaut, le décodage s’arrête à la première erreur. decodeAccumulating recueille au contraire tous les échecs dans un ValidatedNel.
C’est utile pour la validation de formulaires lorsque vous souhaitez signaler tous les problèmes en une seule fois.
import io.circe.Decoder
val result = Decoder[User]
.decodeAccumulating(json.hcursor)
// Validated[NonEmptyList[DecodingFailure], User]Choisir un style de dérivation
Utilisez auto pour les prototypes rapides et semiauto pour le code de production lorsque vous voulez des instances fixes et des compilations plus rapides.
Utilisez generic-extras lorsque vous avez besoin de renommage, de valeurs par défaut ou de discriminateurs.
Vérification rapide
Vérifiez votre compréhension du décodage vers des classes case.
Récapitulatif
Un Decoder[A] transforme du JSON en valeurs typées. Utilisez generic.auto ou semiauto.deriveDecoder pour les classes case dont les noms correspondent aux clés.
Les clés manquantes sont décodées en None pour les champs Option ; generic-extras ajoute les valeurs par défaut et le renommage ; decodeAccumulating rassemble toutes les erreurs.
Questions Fréquemment Posées
La leçon « Décoder vers des classes de cas » est-elle gratuite ?
Oui — le texte complet de « Décoder vers des classes de cas » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Décoder vers des classes de cas » ?
Associez le JSON à vos types. Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Décoder vers des classes de cas » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Analyser du JSON
- Décoder vers des classes de cas
- Encoder en JSON
- Codecs personnalisés