Kotlin Academy · Les

Annotaties lezen tijdens runtime

Haal annotatie-instanties op uit declaraties met Kotlin-reflection.

Les 3 van 413 stappen

Annotaties lezen tijdens runtime is een gratis Kotlin Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Kotlin Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Kotlin Academy bevat in totaal 4 lessen.

Vereisten

Om annotaties tijdens runtime te lezen heb je het volgende nodig: (1) de annotatie moet zijn gedeclareerd met @Retention(RUNTIME), (2) de afhankelijkheid kotlin-reflect moet op het klassenpad staan en (3) een verwijzing naar een KClass, KFunction of KProperty van het geannoteerde element.

Annotaties uit een KClass lezen

Roep annotations aan op een KClass om alle annotaties op die klasse te verkrijgen, of gebruik findAnnotation() voor een specifiek type:

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

Annotaties uit eigenschappen lezen

Open annotaties op eigenschappen via KProperty.annotations of 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"

Annotaties uit functies lezen

Gebruik KFunction.findAnnotation() om annotaties op functies te lezen:

@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

Alle eigenschappen doorlopen op annotaties

Een veelgebruikt patroon is alle gedeclareerde eigenschappen van een klasse te doorzoeken en de eigenschappen te verzamelen die met een specifieke annotatie zijn gemarkeerd:

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

Annotaties op parameters lezen

Open annotaties van constructorparameters 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 versus findAnnotation

Gebruik hasAnnotation() voor een booleaanse controle; gebruik findAnnotation() wanneer je de eigenschapswaarden van de annotatie nodig hebt. Beide zijn uitbreidingsfuncties uit kotlin.reflect.full.

De klassenhiërarchie doorlopen

Annotaties op superklassen of interfaces worden niet automatisch overgenomen in Kotlin-reflectie. Je moet KClass.superclasses doorlopen of KClass.allSuperclasses gebruiken als je overgenomen annotaties nodig hebt.

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

Prestaties

Reflectieaanroepen zijn traag. Als je annotaties scant bij het opstarten van een framework, cache je de resultaten in een map met KClass als sleutel. Lees annotaties nooit in prestatiekritieke paden per verzoek of per frame.

doelen voor gebruikslocaties en JVM-velden

Bij annotaties op eigenschappen met het doel @field: staat de annotatie op het ondersteunende JVM-veld. Open deze via Java-reflectie (KProperty.javaField?.annotations) in plaats van via Kotlin's lijst annotations, die alleen de Kotlin-declaratieplaats omvat.

Praktisch voorbeeld: eenvoudige ORM-mapper

Een kleine ORM-mapper leest annotaties van @Column om een lijst met SQL-kolommen op te bouwen:

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

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

Korte controle

Hoe lees je een specifieke annotatie van het type MyAnn uit een KClass?

Beantwoord dit in de interactieve les

Samenvatting: annotaties tijdens runtime lezen

Belangrijkste punten:

De annotatie moet @Retention(RUNTIME) hebben
Gebruik findAnnotation() om de waarde van een annotatie op te halen en hasAnnotation() voor een booleaanse controle
Werkt op KClass, KFunction, KProperty en KParameter
Cache scanresultaten bij het opstarten om overhead per verzoek te vermijden
Gebruik voor annotaties met @field: KProperty.javaField

Gratis beginnen

Leer Kotlin met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Annotaties lezen tijdens runtime” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Kotlin Academy, waaronder “Annotaties lezen tijdens runtime”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Kotlin Academy bevat in totaal 4 lessen.

Wat leer ik in “Annotaties lezen tijdens runtime”?

Haal annotatie-instanties op uit declaraties met Kotlin-reflection. Je oefent met Kotlin Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Kotlin Academy te beginnen?

Ervaring vooraf is niet nodig. Kotlin Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Annotaties lezen tijdens runtime”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Kotlin Academy?

Ja. Elke les over Kotlin Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Kotlin-reflectie: KClass, KFunction, KProperty
Aangepaste annotaties maken en targeten
Annotaties lezen tijdens runtime
Reflectiegebaseerde validatie en mapping

← Terug naar Kotlin Academy