Kotlin Academy · Lektion

Praktische Reflection

Lesen Sie Annotationen dynamisch aus

Praktische Reflection ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Annotationen und Reflection

Eine Annotation mit der Aufbewahrung RUNTIME kann zur Laufzeit über Reflection gefunden werden. Diese Kombination bildet die Grundlage für Serialisierer, Validatoren und Dependency Injection.

In dieser Lektion lesen wir unsere eigenen Annotationen dynamisch aus.

Eine Klassenannotation auslesen

Jede KClass stellt eine annotations-Liste bereit. Wir können sie durchsuchen, um eine bestimmte Annotation anhand ihres Typs zu finden.

@Retention(AnnotationRetention.RUNTIME)
annotation class Entity(val table: String)

@Entity("users")
class User

fun main() {
    val ann = User::class.annotations
        .filterIsInstance<Entity>()
        .first()
    println(ann.table)
}

Der Helfer findAnnotation

Die Erweiterung findAnnotation ist übersichtlicher, als die Liste manuell zu filtern. Sie gibt die Annotation oder null zurück.

import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Entity(val table: String)

@Entity("orders")
class Order

fun main() {
    val ann = Order::class.findAnnotation<Entity>()
    println(ann?.table)
}

Annotationen auf Properties

Properties besitzen eigene Annotationen. Durchlaufen Sie memberProperties und untersuchen Sie die annotations jeder Property.

import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.findAnnotation

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

class Product(@Column("product_id") val id: Int, val title: String)

fun main() {
    Product::class.memberProperties.forEach { prop ->
        val col = prop.findAnnotation<Column>()
        if (col != null) println(prop.name + " -> " + col.name)
    }
}

Einen Mini-Serializer erstellen

Kombinieren Sie das Lesen von Properties mit Annotationen, um eine Ausgabe zu erzeugen. Hier ordnen wir jeder Property eine Zeichenkette im Format key=value zu und verwenden, sofern vorhanden, den Spaltennamen.

import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.findAnnotation

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

class Item(@Column("item_id") val id: Int, val name: String)

fun main() {
    val item = Item(7, "Book")
    val parts = Item::class.memberProperties.map { p ->
        val key = p.findAnnotation<Column>()?.name ?: p.name
        key + "=" + p.getter.call(item)
    }
    println(parts.joinToString(", "))
}

Mit einem Marker überspringen

Eine Marker-Annotation kann Properties kennzeichnen, die ignoriert werden sollen. Wir prüfen mit hasAnnotation, ob sie vorhanden ist.

import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.hasAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Transient2

class Account(val id: Int, @Transient2 val secret: String)

fun main() {
    Account::class.memberProperties
        .filterNot { it.hasAnnotation<Transient2>() }
        .forEach { println(it.name) }
}

Argumente von Annotationen auslesen

Sobald Sie die Annotation-Instanz haben, sind ihre Parameter ganz normale Properties. Lesen Sie sie wie jedes andere Feld aus.

import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Validated(val min: Int, val max: Int)

@Validated(min = 1, max = 100)
class Quantity

fun main() {
    val v = Quantity::class.findAnnotation<Validated>()!!
    println("range " + v.min + ".." + v.max)
}

Annotationen auf Funktionen

Auch Funktionen können annotiert und untersucht werden. Frameworks nutzen dies, um Handler zu finden, etwa wenn Testrunner Testmethoden ermitteln.

import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Route(val path: String)

class Api {
    @Route("/home")
    fun home() = "home page"
}

fun main() {
    Api::class.memberFunctions.forEach { f ->
        f.findAnnotation<Route>()?.let { println(f.name + " @ " + it.path) }
    }
}

Verhalten steuern

Lesen Sie die Routing-Annotation aus und leiten Sie tatsächlich einen Aufruf weiter. Das ist der Kern der Funktionsweise von Routing-Frameworks.

import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Route(val path: String)

class Api {
    @Route("/ping")
    fun ping() = "pong"
}

fun main() {
    val api = Api()
    val target = "/ping"
    Api::class.memberFunctions.forEach { f ->
        if (f.findAnnotation<Route>()?.path == target) {
            println(f.call(api))
        }
    }
}

Anwendungen in der Praxis

Annotationsgesteuerte Reflection bildet die Grundlage vieler Bibliotheken:

JSON-Serialisierung, die Felder Schlüsseln zuordnet
Validierung, die Einschränkungen durchsetzt
Routing, das Pfade den Handlern zuordnet
Dependency Injection, die Komponenten miteinander verbindet

Gezielter Einsatz

Reflection sollte am besten auf Setup- und Framework-Code beschränkt bleiben, der einmalig oder selten ausgeführt wird. Cachen Sie die Ergebnisse, wann immer möglich. Für häufig ausgeführte Pfade pro Anfrage sollten Sie die Verarbeitung zur Kompilierzeit bevorzugen.

Kurzer Test

Testen Sie Ihr Verständnis der praktischen Verwendung von Reflection.

Zusammenfassung

Sie haben Annotationen und Reflection kombiniert, um:

Annotationen auf Klassen, Properties und Funktionen zu finden
Argumente von Annotationen zur Laufzeit auszulesen
Einen Mini-Serializer und einen Routing-Dispatcher zu erstellen
Felder mit Marker-Annotationen zu überspringen

So werden echte Frameworks entwickelt.

Häufig gestellte Fragen

Ist die Lektion „Praktische Reflection“ kostenlos?

Ja — der vollständige Text von „Praktische Reflection“ 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 „Praktische Reflection“?

Lesen Sie Annotationen dynamisch aus 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 4 von 4.

Wie lange dauert die Lektion „Praktische Reflection“?

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

← Zurück zu Kotlin Academy