0Pricing
Kotlin Academy · Leçon

Lire les annotations à l’exécution

Récupérez les instances d’annotations des déclarations avec la réflexion Kotlin.

Lire les annotations à l’exécution est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Prérequis

Pour lire les annotations à l'exécution, vous avez besoin des éléments suivants : (1) l'annotation doit être déclarée avec @Retention(RUNTIME), (2) la dépendance kotlin-reflect doit se trouver dans le chemin de classes et (3) vous devez disposer d'une référence KClass, KFunction ou KProperty vers l'élément annoté.

Lire les annotations d'une KClass

Appelez annotations sur une KClass pour obtenir toutes les annotations de cette classe, ou utilisez findAnnotation() pour cibler un type précis :

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.CLASS)
annotation class Table(val name: String)

@Table(name = "users")
class UserEntity

val ann = UserEntity::class.findAnnotation<Table>()
println(ann?.name)  // "users"

Lire les annotations des propriétés

Accédez aux annotations des propriétés via KProperty.annotations ou findAnnotation() :

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

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

val prop = User::name
val col = prop.findAnnotation<Column>()
println(col?.name)  // "user_name"

Lire les annotations des fonctions

Utilisez KFunction.findAnnotation() pour lire les annotations des fonctions :

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.FUNCTION)
annotation class Transactional

class UserService {
    @Transactional
    fun save(user: User) { /*...*/ }
}

val fn = UserService::save
val isTx = fn.hasAnnotation<Transactional>()
println(isTx)  // true

Parcourir toutes les propriétés à la recherche d'annotations

Il est courant de parcourir toutes les propriétés déclarées d'une classe et de collecter celles qui portent une annotation précise :

fun <A : Annotation> KClass<*>.annotatedProperties(
    annotationClass: KClass<A>
): List<Pair<KProperty1<*, *>, A>> =
    declaredMemberProperties
        .mapNotNull { prop ->
            prop.findAnnotation(annotationClass)?.let { ann -> prop to ann }
        }

Lire les annotations des paramètres

Accédez aux annotations des paramètres du constructeur via KFunction.parameters :

class Repo(
    @param:Validate(minLength = 3) val name: String
)

val ctor = Repo::class.primaryConstructor!!
val param = ctor.parameters.first()
val ann = param.findAnnotation<Validate>()
println(ann?.minLength)  // 3

hasAnnotation et findAnnotation

Utilisez hasAnnotation() pour une vérification booléenne ; utilisez findAnnotation() lorsque vous avez besoin des valeurs des propriétés de l'annotation. Les deux sont des fonctions d'extension de kotlin.reflect.full.

Parcourir la hiérarchie des classes

Les annotations des superclasses ou des interfaces ne sont PAS héritées automatiquement par la réflexion Kotlin. Vous devez parcourir KClass.superclasses ou utiliser KClass.allSuperclasses si vous avez besoin des annotations héritées.

fun KClass<*>.findAnnotationRecursive(ann: KClass<out Annotation>) =
    generateSequence(this) { null } // simplified — real impl walks supers
        .flatMap { it.annotations }
        .firstOrNull { it.annotationClass == ann }

Performances

Les appels de réflexion sont lents. Si vous parcourez les annotations au démarrage du cadriciel, mettez les résultats en cache dans une table associée à KClass. Ne lisez jamais les annotations dans des chemins très sollicités, exécutés à chaque requête ou à chaque image.

Cibles d'utilisation et champs JVM

Pour les annotations de propriétés avec la cible @field:, l'annotation se trouve sur le champ de stockage JVM. Accédez-y via la réflexion Java (KProperty.javaField?.annotations) plutôt que via la liste annotations de Kotlin, qui ne couvre que le site de déclaration Kotlin.

Exemple pratique : mappeur ORM simple

Un minuscule mappeur ORM lit les annotations @Column pour construire une liste de colonnes SQL :

fun columns(klass: KClass<*>): String =
    klass.declaredMemberProperties
        .mapNotNull { it.findAnnotation<Column>()?.name }
        .joinToString(", ")

println(columns(User::class))  // "user_name, email"

Vérification rapide

Comment lire une annotation précise de type MyAnn à partir d'une KClass ?

Récapitulatif : lire les annotations à l'exécution

Points essentiels :

  • L'annotation doit posséder @Retention(RUNTIME)
  • Utiliser findAnnotation() pour obtenir la valeur d'une annotation et hasAnnotation() pour une vérification booléenne
  • Fonctionne sur KClass, KFunction, KProperty et KParameter
  • Mettre les résultats du parcours en cache au démarrage pour éviter le surcoût à chaque requête
  • Pour les annotations @field:, utiliser KProperty.javaField

Questions Fréquemment Posées

La leçon « Lire les annotations à l’exécution » est-elle gratuite ?

Oui — le texte complet de « Lire les annotations à l’exécution » 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 « Lire les annotations à l’exécution » ?

Récupérez les instances d’annotations des déclarations avec la réflexion Kotlin. 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 3 sur 4.

Combien de temps prend la leçon « Lire les annotations à l’exécution » ?

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