Was ist Reflexion und wie wird sie in Kotlin implementiert?

Reflexion in Kotlin ist die Möglichkeit, Eigenschaften von Objekten, Klassen und deren Mitgliedern zur Laufzeit zu untersuchen. Sie ermöglicht es, Informationen über den Objekttyp, seine Methoden, Felder, Konstruktoren und Anmerkungen zu erhalten sowie Methoden dynamisch aufzurufen und Feldwerte zu ändern.

In Kotlin wird Reflexion durch eine API im Paket kotlin.reflect implementiert. Um mit Reflexion zu arbeiten, muss die Abhängigkeit kotlin-reflect hinzugefügt werden. Diese API bietet Klassen, die verschiedene Elemente der Sprache repräsentieren:

• KClass: repräsentiert eine Klasse. Ermöglicht das Abrufen des Klassennamens, der Konstruktoren, Mitglieder (Methoden und Eigenschaften), Superklassen usw.
• KCallable: allgemeine Schnittstelle für Funktionen und Eigenschaften, die aufgerufen werden können.
• KFunction: repräsentiert eine Funktion. Ermöglicht das Abrufen der Parameter, des Rückgabetyps und das Aufrufen der Funktion.
• KProperty: repräsentiert eine Eigenschaft (Mitgliedsvariable). Ermöglicht das Abrufen des Eigenschaftstyps, ihrer Sichtbarkeit, Annotationen sowie das Lesen oder Schreiben ihres Wertes.

Zur Erzeugung reflexiver Objekte werden die Operatoren :: für Klassen, Funktionen und Eigenschaften verwendet, oder die Methoden des Typs .java.kotlin, um eine KClass aus einer Java Class zu erhalten.

Beispiele:

// KClass mit dem Operator ::class erhalten
val personClass: KClass<Person> = Person::class

// KClass aus einer Java-Klasse erhalten
val personJavaClass: Class<Person> = Person::class.java
val personKotlinClass: KClass<Person> = personJavaClass.kotlin

// Liste der Konstruktoren der Klasse erhalten
val constructors = personClass.constructors

// Liste der Mitglieder der Klasse (Eigenschaften und Funktionen) erhalten
val members = personClass.members

// KFunction für eine Methode erhalten
val sayHelloFunction: KFunction<*> = personClass.members.find { it.name == "sayHello" } as KFunction<*>

// Methode via Reflexion aufrufen
val personInstance = Person("Alice")
sayHelloFunction.call(personInstance)

// KProperty für eine Eigenschaft erhalten
val nameProperty: KProperty1<Person, String> = personClass.members.find { it.name == "name" } as KProperty1<Person, String>

// Wert einer Eigenschaft via Reflexion erhalten
val nameValue = nameProperty.get(personInstance)

// Wert einer Eigenschaft via Reflexion setzen (für veränderliche Eigenschaften)
// val mutableNameProperty = personClass.members.find { it.name == "mutableName" } as KMutableProperty1<Person, String>
// mutableNameProperty.set(personInstance, "Bob")

Reflexion ist nützlich für:

• Metaprogrammierung (ORM-Frameworks, Serialisierung/Deserialisierung).
• Erstellen von dynamischen Proxys und Aspekten.
• Testen (Zugriff auf private Mitglieder).
• Laufzeit-Inspektion.

Es ist wichtig zu beachten, dass die Verwendung von Reflexion die Leistung verringern und den Code verkomplizieren kann, außerdem weniger sicher sein kann, da Zugriffsmodifikatoren umgangen werden. Sie sollte bewusst und dort eingesetzt werden, wo andere Ansätze ineffizient oder unmöglich sind.