Kotlin Academy · Leçon

Sérialiseurs personnalisés

Gérer les types particuliers

Sérialiseurs personnalisés est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 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 Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Pourquoi des sérialiseurs personnalisés ?

Certains types ne disposent d'aucun sérialiseur intégré : java.util.Date, LocalDate, UUID ou des types provenant de bibliothèques tierces.

Un sérialiseur personnalisé définit la manière dont un tel type est converti depuis et vers une forme sérialisée.

L'interface KSerializer

Un sérialiseur personnalisé implémente KSerializer<T> avec trois membres : descriptor, serialize et deserialize.

import kotlinx.serialization.KSerializer
import kotlinx.serialization.descriptors.SerialDescriptor
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder

Un sérialiseur pour LocalDate

Convertissez un LocalDate depuis et vers une chaîne ISO. Le descripteur le déclare comme une chaîne primitive.

import java.time.LocalDate
import kotlinx.serialization.KSerializer
import kotlinx.serialization.descriptors.PrimitiveKind
import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
import kotlinx.serialization.descriptors.SerialDescriptor
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder

object LocalDateSerializer : KSerializer<LocalDate> {
    override val descriptor: SerialDescriptor =
        PrimitiveSerialDescriptor("LocalDate", PrimitiveKind.STRING)
    override fun serialize(encoder: Encoder, value: LocalDate) =
        encoder.encodeString(value.toString())
    override fun deserialize(decoder: Decoder): LocalDate =
        LocalDate.parse(decoder.decodeString())
}

Utiliser @Serializable(with = ...)

Appliquez le sérialiseur à une propriété précise avec @Serializable(with = ...).

import java.time.LocalDate
import kotlinx.serialization.Serializable

@Serializable
data class Event(
    val name: String,
    @Serializable(with = LocalDateSerializer::class)
    val date: LocalDate
)

@UseSerializers au niveau du fichier

Pour éviter d'annoter chaque propriété, déclarez les sérialiseurs une seule fois par fichier avec @file:UseSerializers.

@file:UseSerializers(LocalDateSerializer::class)

import kotlinx.serialization.UseSerializers
import java.time.LocalDate
import kotlinx.serialization.Serializable

@Serializable
data class Event(val name: String, val date: LocalDate)

Sérialisation contextuelle

Enregistrez les sérialiseurs globalement dans le module Json { } et marquez les propriétés avec @Contextual. Le sérialiseur est résolu à l'exécution depuis le module.

import kotlinx.serialization.Contextual
import kotlinx.serialization.Serializable
import java.time.LocalDate

@Serializable
data class Event(val name: String, @Contextual val date: LocalDate)

Enregistrer un SerializersModule

Créez un module qui associe le type à son sérialiseur, puis transmettez-le à Json.

import kotlinx.serialization.json.Json
import kotlinx.serialization.modules.SerializersModule
import java.time.LocalDate

val module = SerializersModule {
    contextual(LocalDate::class, LocalDateSerializer)
}
val json = Json { serializersModule = module }

Sérialiseurs composites

Pour les types comportant plusieurs champs, utilisez encodeStructure / decodeStructure avec un descripteur structuré plutôt qu'un descripteur primitif.

import kotlinx.serialization.descriptors.buildClassSerialDescriptor
import kotlinx.serialization.descriptors.element

val descriptor = buildClassSerialDescriptor("Color") {
    element<Int>("r")
    element<Int>("g")
    element<Int>("b")
}

Modèle du type intermédiaire

Une solution plus simple consiste à sérialiser une classe de données privée servant de type intermédiaire, que le compilateur prend déjà en charge, puis à la convertir depuis et vers votre type réel. Cela demande moins de code répétitif que l'encodage et le décodage manuels.

import kotlinx.serialization.Serializable

@Serializable
private data class ColorSurrogate(val r: Int, val g: Int, val b: Int)

Choisir une approche

Choisissez l'approche la plus légère adaptée à votre cas :

@Serializable(with=) — une propriété
@UseSerializers — tout un fichier
@Contextual + module — pour toute l'application, avec résolution à l'exécution
Type intermédiaire — types composites avec un minimum de code

Descripteur primitif ou structuré

Le descripteur doit correspondre à la manière dont vous encodez les données :

Une seule valeur (chaîne/entier) → PrimitiveSerialDescriptor
Plusieurs champs → buildClassSerialDescriptor

Une incompatibilité provoque des erreurs de sérialisation à l'exécution.

Vérification rapide

Vous souhaitez sérialiser un seul LocalDate sous la forme d'une chaîne ISO. Quel descripteur convient ?

Récapitulatif

Les sérialiseurs personnalisés prennent en charge les types que le greffon ne connaît pas :

Implémenter KSerializer<T> avec un descripteur, serialize et deserialize
Appliquer le sérialiseur avec @Serializable(with=), @UseSerializers ou @Contextual et un module
Faire correspondre le type de descripteur à votre encodage

Vous avez ainsi terminé le cours sur la sérialisation.

Questions Fréquemment Posées

La leçon « Sérialiseurs personnalisés » est-elle gratuite ?

Oui — le texte complet de « Sérialiseurs personnalisés » 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 Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Sérialiseurs personnalisés » ?

Gérer les types particuliers Tu pratiques Kotlin Academy 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 Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy 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 4 sur 4.

Combien de temps prend la leçon « Sérialiseurs personnalisés » ?

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 Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy 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

← Retour à Kotlin Academy