Kotlin Academy · Leçon

Réflexion pratique

Lire les annotations dynamiquement

Réflexion pratique 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.

Annotations et réflexion

Une annotation conservée avec RUNTIME peut être découverte à l'exécution par réflexion. Cette combinaison est à la base des sérialiseurs, des validateurs et de l'injection de dépendances.

Dans cette leçon, nous lisons dynamiquement nos propres annotations.

Lire une annotation de classe

Chaque KClass expose une liste annotations. Nous pouvons la parcourir pour trouver une annotation particulière par son type.

@Retention(AnnotationRetention.RUNTIME)
annotation class Entity(val table: String)

@Entity("users")
class User

fun main() {
    val ann = User::class.annotations
        .filterIsInstance<Entity>()
        .first()
    println(ann.table)
}

Assistant findAnnotation

L'extension findAnnotation est plus claire qu'un filtrage manuel. Elle renvoie l'annotation ou null.

import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Entity(val table: String)

@Entity("orders")
class Order

fun main() {
    val ann = Order::class.findAnnotation<Entity>()
    println(ann?.table)
}

Annotations sur les propriétés

Les propriétés possèdent leurs propres annotations. Parcourez memberProperties et inspectez les annotations de chaque propriété.

import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.findAnnotation

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

class Product(@Column("product_id") val id: Int, val title: String)

fun main() {
    Product::class.memberProperties.forEach { prop ->
        val col = prop.findAnnotation<Column>()
        if (col != null) println(prop.name + " -> " + col.name)
    }
}

Construire un mini-sérialiseur

Combinez la lecture des propriétés et les annotations pour générer une sortie. Ici, nous associons chaque propriété à une chaîne clé=valeur en utilisant le nom de colonne lorsqu'il est présent.

import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.findAnnotation

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

class Item(@Column("item_id") val id: Int, val name: String)

fun main() {
    val item = Item(7, "Book")
    val parts = Item::class.memberProperties.map { p ->
        val key = p.findAnnotation<Column>()?.name ?: p.name
        key + "=" + p.getter.call(item)
    }
    println(parts.joinToString(", "))
}

Ignorer avec un marqueur

Une annotation marqueur peut signaler les propriétés à ignorer. Nous vérifions sa présence avec hasAnnotation.

import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.hasAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Transient2

class Account(val id: Int, @Transient2 val secret: String)

fun main() {
    Account::class.memberProperties
        .filterNot { it.hasAnnotation<Transient2>() }
        .forEach { println(it.name) }
}

Lire les arguments des annotations

Une fois l'instance de l'annotation obtenue, ses paramètres sont de simples propriétés. Lisez-les comme n'importe quel champ.

import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Validated(val min: Int, val max: Int)

@Validated(min = 1, max = 100)
class Quantity

fun main() {
    val v = Quantity::class.findAnnotation<Validated>()!!
    println("range " + v.min + ".." + v.max)
}

Annotations sur les fonctions

Les fonctions peuvent également être annotées et inspectées. Les infrastructures utilisent cette possibilité pour trouver des gestionnaires, comme les exécuteurs d'évaluations qui localisent les méthodes d'évaluation.

import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Route(val path: String)

class Api {
    @Route("/home")
    fun home() = "home page"
}

fun main() {
    Api::class.memberFunctions.forEach { f ->
        f.findAnnotation<Route>()?.let { println(f.name + " @ " + it.path) }
    }
}

Piloter le comportement

Lisez l'annotation de routage et acheminez effectivement un call. C'est l'essence du fonctionnement des infrastructures de routage.

import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Route(val path: String)

class Api {
    @Route("/ping")
    fun ping() = "pong"
}

fun main() {
    val api = Api()
    val target = "/ping"
    Api::class.memberFunctions.forEach { f ->
        if (f.findAnnotation<Route>()?.path == target) {
            println(f.call(api))
        }
    }
}

Utilisations concrètes

La réflexion pilotée par les annotations est à la base de nombreuses bibliothèques :

Sérialisation JSON associant les champs à des clés
Validation imposant des contraintes
Routage faisant correspondre les chemins aux gestionnaires
Injection de dépendances reliant les composants

Limiter la réflexion

Il vaut mieux limiter la réflexion à l'initialisation et au code d'infrastructure exécuté une seule fois ou rarement. Mettez les résultats en cache lorsque c'est possible. Pour les chemins très sollicités par requête, préférez le traitement au moment de la compilation.

Vérification rapide

Vérifiez votre compréhension de la réflexion en pratique.

Récapitulatif

Vous avez combiné les annotations et la réflexion pour :

Trouver les annotations de classes, de propriétés et de fonctions
Lire les arguments des annotations à l'exécution
Construire un mini-sérialiseur et un répartiteur de routage
Ignorer les champs portant des annotations marqueurs

C'est ainsi que sont construites les véritables infrastructures.

Questions Fréquemment Posées

La leçon « Réflexion pratique » est-elle gratuite ?

Oui — le texte complet de « Réflexion pratique » 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 « Réflexion pratique » ?

Lire les annotations dynamiquement 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 « Réflexion pratique » ?

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