0Pricing
Kotlin Academy · Lektion

Annotationen zur Laufzeit auslesen

Rufen Sie Annotation-Instanzen mithilfe von Kotlin Reflection aus Deklarationen ab.

Annotationen zur Laufzeit auslesen ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Voraussetzungen

Um Annotationen zur Laufzeit auszulesen, benötigen Sie: (1) eine mit @Retention(RUNTIME) deklarierte Annotation, (2) die Abhängigkeit kotlin-reflect im Classpath und (3) eine KClass-, KFunction- oder KProperty-Referenz auf das annotierte Element.

Annotationen aus einer KClass auslesen

Rufen Sie annotations auf einer KClass auf, um alle Annotationen dieser Klasse abzurufen, oder verwenden Sie findAnnotation() für einen bestimmten 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"

Annotationen aus Properties auslesen

Greifen Sie über KProperty.annotations oder findAnnotation() auf Annotationen von Properties zu:

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

Annotationen aus Funktionen auslesen

Verwenden Sie KFunction.findAnnotation(), um Annotationen von Funktionen auszulesen:

@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 Properties auf Annotationen untersuchen

Ein häufig verwendetes Muster besteht darin, alle deklarierten Properties einer Klasse zu durchsuchen und diejenigen zu sammeln, die mit einer bestimmten Annotation versehen sind:

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

Annotationen von Parametern auslesen

Greifen Sie über KFunction.parameters auf Annotationen von Konstruktorparametern zu:

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 vs findAnnotation

Verwenden Sie hasAnnotation() für eine boolesche Prüfung und findAnnotation(), wenn Sie die Property-Werte der Annotation benötigen. Beide sind Erweiterungsfunktionen aus kotlin.reflect.full.

Die Klassenhierarchie durchlaufen

Annotationen von Oberklassen oder Interfaces werden in der Kotlin-Reflection nicht automatisch vererbt. Sie müssen KClass.superclasses durchlaufen oder KClass.allSuperclasses verwenden, wenn Sie geerbte Annotationen benötigen.

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

Performance

Reflection-Aufrufe sind langsam. Wenn Sie beim Start eines Frameworks Annotationen durchsuchen, cachen Sie die Ergebnisse in einer Map mit KClass als Schlüssel. Lesen Sie Annotationen niemals in Hot Paths pro Anfrage oder Frame aus.

Use-Site-Targets und JVM-Felder

Bei Annotationen von Properties mit dem Ziel @field: befindet sich die Annotation auf dem JVM-Backing-Feld. Greifen Sie über Java-Reflection darauf zu (KProperty.javaField?.annotations) und nicht über die Kotlin-Liste annotations, die nur die Kotlin-Deklarationsstelle abdeckt.

Praxisbeispiel: Einfacher ORM-Mapper

Ein kleiner ORM-Mapper liest @Column-Annotationen aus, um eine Liste von SQL-Spalten zu erstellen:

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

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

Schnelltest

Wie lesen Sie eine bestimmte Annotation vom Typ MyAnn aus einer KClass aus?

Zusammenfassung: Annotationen zur Laufzeit auslesen

Wichtige Erkenntnisse:

  • Die Annotation muss @Retention(RUNTIME) verwenden
  • Verwenden Sie findAnnotation(), um den Wert einer Annotation abzurufen, und hasAnnotation() für eine boolesche Prüfung
  • Funktioniert mit KClass, KFunction, KProperty und KParameter
  • Cachen Sie Suchergebnisse beim Start, um zusätzlichen Aufwand pro Anfrage zu vermeiden
  • Verwenden Sie für @field:-Annotationen KProperty.javaField

Häufig gestellte Fragen

Ist die Lektion „Annotationen zur Laufzeit auslesen“ kostenlos?

Ja — der vollständige Text von „Annotationen zur Laufzeit auslesen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Annotationen zur Laufzeit auslesen“?

Rufen Sie Annotation-Instanzen mithilfe von Kotlin Reflection aus Deklarationen ab. Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Annotationen zur Laufzeit auslesen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Kotlin Reflection: KClass, KFunction, KProperty
  2. Benutzerdefinierte Annotationen erstellen und anwenden
  3. Annotationen zur Laufzeit auslesen
  4. Reflection-basierte Validierung und Zuordnung
← Zurück zu Kotlin Academy