0Pricing
Kotlin Academy · Leçon

Validation et mappage fondés sur la réflexion

Construisez un validateur ou un mappeur d’objets simple à l’aide de la réflexion pilotée par les annotations.

Validation et mappage fondés sur la réflexion 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.

À quoi sert ce modèle

La validation fondée sur la réflexion lit les annotations des propriétés d'une classe à l'exécution et applique automatiquement les règles de validation — sans vérifications manuelles pour chaque champ. La même technique alimente les mappeurs ORM qui convertissent les objets en lignes de base de données, et inversement.

L’annotation Validate

Définissez une annotation conservée à l’exécution et ciblant les propriétés :

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.PROPERTY)
annotation class Validate(
    val minLength: Int = 0,
    val maxLength: Int = Int.MAX_VALUE,
    val pattern: String = ""
)

Annoter une classe de données

Appliquez @Validate aux propriétés d’une classe de données. Le validateur les analysera à l’exécution :

data class UserForm(
    @Validate(minLength = 2, maxLength = 50) val name: String,
    @Validate(pattern = "^[\\w.]+@[\\w]+\\.[a-z]{2,}$") val email: String,
    @Validate(minLength = 8) val password: String
)

La fonction de validation

Utilisez KClass.declaredMemberProperties pour parcourir les propriétés, rechercher les annotations et recueillir les erreurs :

fun validate(obj: Any): List<String> {
    val errors = mutableListOf<String>()
    for (prop in obj::class.declaredMemberProperties) {
        val ann = prop.findAnnotation<Validate>() ?: continue
        val value = (prop as KProperty1<Any, *>).get(obj)?.toString() ?: ""
        if (value.length < ann.minLength) errors += "${prop.name}: too short"
        if (value.length > ann.maxLength) errors += "${prop.name}: too long"
        if (ann.pattern.isNotEmpty() && !value.matches(Regex(ann.pattern)))
            errors += "${prop.name}: invalid format"
    }
    return errors
}

Exécuter le validateur

Appelez validate() avec n’importe quel objet annoté. La fonction renvoie une liste de messages d’erreur ; une liste vide signifie que l’objet est valide :

val form = UserForm("A", "not-an-email", "short")
val errors = validate(form)
errors.forEach(::println)
// name: too short
// email: invalid format
// password: too short

Mappage d’un objet vers une Map avec @Column

Un autre modèle de réflexion consiste à mapper un objet vers une Map en utilisant une annotation @Column pour fournir les noms de colonnes :

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.PROPERTY)
annotation class Column(val name: String)

fun toMap(obj: Any): Map<String, Any?> =
    obj::class.declaredMemberProperties
        .mapNotNull { prop ->
            val col = prop.findAnnotation<Column>() ?: return@mapNotNull null
            col.name to (prop as KProperty1<Any, *>).get(obj)
        }.toMap()

Utiliser le mappeur

Annotez la classe de données et appelez toMap() pour obtenir une map indexée par les clés de colonne, prête pour une instruction INSERT :

data class User(
    @Column("user_name") val name: String,
    @Column("user_email") val email: String
)

val user = User("Alice", "alice@example.com")
println(toMap(user))
// {user_name=Alice, user_email=alice@example.com}

Mettre en cache les résultats de la réflexion

Les analyses par réflexion sont coûteuses. Mettez en cache au démarrage le mappage propriété-annotation à l’aide d’une ConcurrentHashMap indexée par KClass :

val cache = ConcurrentHashMap<KClass<*>, List<Pair<KProperty1<Any,*>, Column>>>()

fun columnsOf(klass: KClass<*>) = cache.getOrPut(klass) {
    klass.declaredMemberProperties
        .mapNotNull { p ->
            p.findAnnotation<Column>()?.let { (p as KProperty1<Any,*>) to it }
        }
}

Combiner validation et mappage

Vous pouvez empiler des annotations sur une même propriété et traiter chacune d’elles indépendamment. Validez d’abord, puis mappez — ou effectuez les deux en un seul parcours en recueillant chaque type d’annotation :

data class Product(
    @Validate(minLength = 1) @Column("product_name") val name: String,
    @Column("price") val price: Double
)

Limitations

La validation fondée sur la réflexion est puissante, mais elle présente des compromis : elle ajoute une surcharge à l’exécution, dépend de la conservation des annotations et ne peut pas détecter les erreurs lors de la compilation. Pour une validation critique en matière de performances ou sûre à la compilation, envisagez plutôt du code généré par KSP.

Quand utiliser ce modèle

La validation fondée sur la réflexion est particulièrement adaptée au code de framework qui doit gérer des classes définies arbitrairement par les utilisateurs : ORM, sérialiseurs, validateurs de formulaires et lieurs de configuration. Le code applicatif qui maîtrise ses types devrait privilégier une validation explicite, pour plus de rapidité et de clarté.

Vérification rapide

Quelle politique de conservation des annotations est requise pour qu’une annotation de validation soit lisible à l’exécution ?

Récapitulatif : validation et mappage fondés sur la réflexion

Points essentiels :

  • Déclarez des annotations conservées à l’exécution et ciblant les propriétés
  • Utilisez declaredMemberProperties et findAnnotation pour piloter la validation ou le mappage
  • Mettez les résultats en cache par KClass afin d’éviter la surcharge répétée de la réflexion
  • Empilez plusieurs annotations sur une propriété pour combiner les comportements
  • Envisagez KSP comme solution de remplacement lors de la compilation pour les chemins critiques en matière de performances

Questions Fréquemment Posées

La leçon « Validation et mappage fondés sur la réflexion » est-elle gratuite ?

Oui — le texte complet de « Validation et mappage fondés sur la réflexion » 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 « Validation et mappage fondés sur la réflexion » ?

Construisez un validateur ou un mappeur d’objets simple à l’aide de la réflexion pilotée par les annotations. 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 « Validation et mappage fondés sur la réflexion » ?

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

  1. Réflexion Kotlin : KClass, KFunction, KProperty
  2. Créer et cibler des annotations personnalisées
  3. Lire les annotations à l’exécution
  4. Validation et mappage fondés sur la réflexion
← Retour à Kotlin Academy