0Pricing
Kotlin Academy · Lezione

Leggere le annotazioni a runtime

Recuperi le istanze delle annotazioni dalle dichiarazioni usando la reflection di Kotlin.

Leggere le annotazioni a runtime è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Prerequisiti

Per leggere le annotazioni a runtime sono necessari: (1) un'annotazione dichiarata con @Retention(RUNTIME), (2) la dipendenza kotlin-reflect nel classpath e (3) un riferimento KClass, KFunction o KProperty all'elemento annotato.

Leggere le annotazioni da una KClass

Chiami annotations su una KClass per ottenere tutte le annotazioni di quella classe oppure usi findAnnotation() per un tipo specifico:

@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"

Leggere le annotazioni dalle proprietà

Acceda alle annotazioni delle proprietà tramite KProperty.annotations o 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"

Leggere le annotazioni dalle funzioni

Usi KFunction.findAnnotation() per leggere le annotazioni delle funzioni:

@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

Iterare tutte le proprietà per cercare annotazioni

Un pattern comune consiste nell'analizzare tutte le proprietà dichiarate di una classe e raccogliere quelle annotate con una specifica annotazione:

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

Leggere le annotazioni sui parametri

Acceda alle annotazioni dei parametri del costruttore tramite 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 rispetto a findAnnotation

Usi hasAnnotation() per un controllo booleano; usi findAnnotation() quando ha bisogno dei valori delle proprietà dell'annotazione. Entrambe sono funzioni di estensione di kotlin.reflect.full.

Esplorare la gerarchia delle classi

Le annotazioni sulle superclassi o sulle interfacce NON vengono ereditate automaticamente dalla reflection di Kotlin. Deve percorrere KClass.superclasses oppure usare KClass.allSuperclasses se ha bisogno delle annotazioni ereditate.

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

Prestazioni

Le chiamate di reflection sono lente. Se analizza le annotazioni all'avvio del framework, memorizzi i risultati nella cache di una mappa indicizzata per KClass. Non legga mai le annotazioni nei percorsi ad alta frequenza per richiesta o per frame.

Target use-site e campi JVM

Per le annotazioni sulle proprietà con target @field:, l'annotazione risiede nel backing field della JVM. Vi acceda tramite la reflection Java (KProperty.javaField?.annotations) invece di usare l'elenco annotations di Kotlin, che copre solo il sito di dichiarazione Kotlin.

Esempio pratico: semplice mapper ORM

Un piccolo mapper ORM legge le annotazioni @Column per creare un elenco di colonne SQL:

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

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

Verifica rapida

Come si legge da una KClass un'annotazione specifica di tipo MyAnn?

Riepilogo: leggere le annotazioni a runtime

Concetti chiave:

  • L'annotazione deve avere @Retention(RUNTIME)
  • Usare findAnnotation() per ottenere il valore di un'annotazione e hasAnnotation() per un controllo booleano
  • Funziona con KClass, KFunction, KProperty e KParameter
  • Memorizzare nella cache i risultati dell'analisi all'avvio per evitare il sovraccarico per richiesta
  • Per le annotazioni @field:, usare KProperty.javaField

Domande Frequenti

La lezione «Leggere le annotazioni a runtime» è gratuita?

Sì — il testo completo di «Leggere le annotazioni a runtime» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Leggere le annotazioni a runtime»?

Recuperi le istanze delle annotazioni dalle dichiarazioni usando la reflection di Kotlin. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Leggere le annotazioni a runtime»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Reflection di Kotlin: KClass, KFunction, KProperty
  2. Creare e applicare annotazioni personalizzate
  3. Leggere le annotazioni a runtime
  4. Validazione e mapping basati sulla reflection
← Torna a Kotlin Academy