Kotlin Academy · Lektion

Läs annotationer under körning

Hämta instanser av annotationer från deklarationer med Kotlin reflection.

Lektion 3 av 413 steg

Läs annotationer under körning är en gratis lektion i Kotlin Academy på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Kotlin Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Kotlin Academy innehåller totalt 4 lektioner.

Förkunskaper

För att läsa annoteringar under körning behöver du: (1) en annotering som deklarerats med @Retention(RUNTIME), (2) beroendet kotlin-reflect på classpath och (3) en referens till det annoterade elementet av typen KClass, KFunction eller KProperty.

Läsa annoteringar från en KClass

Anropa annotations på en KClass för att hämta alla annoteringar på klassen, eller använd findAnnotation() för en specifik typ:

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

Läsa annoteringar från egenskaper

Åtkomst till annoteringar på egenskaper via KProperty.annotations eller 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"

Läsa annoteringar från funktioner

Använd KFunction.findAnnotation() för att läsa annoteringar på funktioner:

@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

Iterera över alla egenskaper för att hitta annoteringar

Ett vanligt mönster är att skanna alla deklarerade egenskaper i en klass och samla dem som har en viss annotering:

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

Läsa annoteringar på parametrar

Åtkomst till annoteringar på konstruktorparametrar 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 jämfört med findAnnotation

Använd hasAnnotation() för en boolesk kontroll och findAnnotation() när du behöver annoteringens egenskapsvärden. Båda är extension-funktioner från kotlin.reflect.full.

Gå igenom klasshierarkin

Annoteringar på superklasser eller gränssnitt är INTEvs automatiskt i Kotlin reflection. Du måste gå igenom KClass.superclasses eller använda KClass.allSuperclasses om du behöver ärvda annoteringar.

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

Prestanda

Reflection-anrop är långsamma. Om du skannar annoteringar när ramverket startar bör du cacha resultaten i en map där nyckeln är KClass. Läs aldrig annoteringar i prestandakritiska kodvägar per begäran eller bildruta.

use-site-targets och JVM-fält

För annoteringar på egenskaper med målet @field: finns annoteringen på JVM:s underliggande fält. Åtkomst till den via Java reflection (KProperty.javaField?.annotations) i stället för Kotlins lista annotations, som endast omfattar Kotlin-deklarationens plats.

Praktiskt exempel: enkel ORM-mappare

En liten ORM-mappare läser @Column-annoteringar för att skapa en lista med SQL-kolumner:

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

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

Snabbkontroll

Hur läser du en specifik annotering av typen MyAnn från en KClass?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Läsa annoteringar under körning

Viktiga slutsatser:

Annoteringen måste ha @Retention(RUNTIME)
Använd findAnnotation() för att hämta en annoterings värde och hasAnnotation() för en boolesk kontroll
Fungerar med KClass, KFunction, KProperty och KParameter
Cacha skanningsresultat vid start för att undvika kostnader per begäran
För annoteringar med @field: använder du KProperty.javaField

Gratis att börja

Lär dig Kotlin med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Läs annotationer under körning” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Kotlin Academy, inklusive ”Läs annotationer under körning”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Kotlin Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Läs annotationer under körning”?

Hämta instanser av annotationer från deklarationer med Kotlin reflection. Ni övar på Kotlin Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Kotlin Academy?

Du behöver inga förkunskaper. Utbildningen i Kotlin Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Läs annotationer under körning”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Kotlin Academy-lektionen?

Ja. Varje Kotlin Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Kotlin Reflection: KClass, KFunction, KProperty
Skapa och målinrikta egna annotationer
Läs annotationer under körning
Reflection-baserad validering och mappning

← Tillbaka till Kotlin Academy