Wie verwendet man Annotations in Kotlin?

Anmerkungen in Kotlin werden verwendet, um Metainformationen zu Klassen, Eigenschaften, Funktionen, Ausdrücken und Parametern hinzuzufügen. Sie führen keine direkten Aktionen aus, können aber vom Compiler, Frameworks oder anderen Bibliotheken für verschiedene Verarbeitungen genutzt werden.

Hauptaspekte der Verwendung:

1. Syntax: Anmerkungen werden vor dem Element platziert, auf das sie angewendet werden, gefolgt von @. Wenn die Anmerkung Parameter hat, werden diese in Klammern nach dem Namen angegeben.

   @Deprecated("Verwenden Sie stattdessen newFunction")
   fun oldFunction() {
       // ...
   }
   
   @JvmStatic
   fun staticMethod() {
       // ...
   }
   

2. Anwendung auf verschiedene Elemente: Anmerkungen können angewendet werden auf:

   • Klassen (class):

     @Serializable
     class User(val name: String)
     

   • Eigenschaften (val, var):

     @Inject
     lateinit var userRepository: UserRepository
     

   • Funktionen (fun):

     @Test
     fun testSomething() {
         // ...
     }
     

   • Parameter von Konstruktoren/Funktionen:

     fun processUser(@NotNull user: User) {
         // ...
     }
     

   • Ausdrücke:

     fun calculate(@Ignore parameter: Int) {
         // ...
     }
     

   • Typen (@Target(AnnotationTarget.TYPE)):

     val list: @NotNull List<String> = emptyList()
     

3. Verwendungsorte (Use-site Targets): Um zu disambiguieren, auf welches Element die Annotation angewendet wird, wenn mehrere vorhanden sind (z.B. Feld und Getter), werden use-site targets verwendet.

   Target	Beschreibung
   @file:	Wird auf die gesamte Datei angewendet
   @property:	Wird auf die gesamte Eigenschaft angewendet
   @field:	Wird auf das Backing-Feld angewendet
   @get:	Wird auf den Getter der Eigenschaft angewendet
   @set:	Wird auf den Setter der Eigenschaft angewendet
   @param:	Wird auf den Parameter des Konstruktors angewendet
   @setparam:	Wird auf den Parameter des Setters angewendet
   @delegate:	Wird auf die Instanz der delegierten Eigenschaft angewendet
   @receiver:	Wird auf den Empfängertyp angewendet

   class Example(@field:Inject val dependency: Dependency) {
       // @field:Inject wird auf das Feld 'dependency' angewendet
   }
   

4. Deklaration eigener Anmerkungen: Eigene Anmerkungen werden mit dem Schlüsselwort annotation class deklariert. Die Parameter der Anmerkung können primitive Typen, Strings, Klassen (KClass), Enumerationen, andere Anmerkungen oder Arrays dieser Typen sein.

   annotation class MyAnnotation(val value: String, val count: Int = 0)
   
   @MyAnnotation("Hallo", count = 5)
   class AnnotatedClass {
       // ...
   }
   

5. Meta-Anmerkungen: Anmerkungen können mit Meta-Anmerkungen versehen werden, die ihr Verhalten und ihre Anwendbarkeit definieren.

   • @Target: Gibt an, welche Elemente annotiert werden können.
   • @Retention: Gibt an, in welcher Lebensphase die Anmerkung vorhanden ist (SOURCE, BINARY, RUNTIME).
   • @Repeatable: Ermöglicht die wiederholte Anwendung der Anmerkung.
   • @MustBeDocumented: Gibt an, dass die Anmerkung Teil der öffentlichen API sein soll, die vom Dokumentationstool generiert wird.

   @Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
   @Retention(AnnotationRetention.RUNTIME)
   annotation class ProcessedByFramework
   

Anmerkungen werden in Kotlin breit eingesetzt, um die Integration mit JVM-Frameworks (Spring, Android), Serialisierung (Kotlinx.serialization), Tests (JUnit) und die Erstellung eigener Bibliotheken auf Basis von Metainformationen zu ermöglichen.