Hoe gebruik je annotaties in Kotlin?

Annotaties in Kotlin worden gebruikt om meta-informatie toe te voegen aan klassen, eigenschappen, functies, uitdrukkingen en parameters. Ze voeren geen directe actie uit, maar kunnen door de compiler, frameworks of andere bibliotheken worden gebruikt voor verschillende verwerking.

Belangrijke aspecten van gebruik:

1. Syntax: Annotaties worden vóór het element geplaatst waarop ze van toepassing zijn, voorafgegaan door @. Als de annotatie parameters heeft, worden deze tussen haakjes na de naam gespecificeerd.

   @Deprecated("Gebruik in plaats daarvan newFunction")
   fun oldFunction() {
       // ...
   }
   
   @JvmStatic
   fun staticMethod() {
       // ...
   }
   

2. Toepassing op verschillende elementen: Annotaties kunnen worden toegepast op:

   • Klassen (class):

     @Serializable
     class User(val name: String)
     

   • Eigenschappen (val, var):

     @Inject
     lateinit var userRepository: UserRepository
     

   • Functies (fun):

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

   • Parameters van constructors/functies:

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

   • Uitdrukkingen:

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

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

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

3. Plaatsen van toepassing (Use-site Targets): Om te disambigueren op welk element de annotatie precies wordt toegepast, wanneer er meerdere zijn (bijvoorbeeld, veld en getter), worden use-site targets gebruikt.

   Target	Beschrijving
   @file:	Toepassen op het hele bestand
   @property:	Toepassen op de hele eigenschap
   @field:	Toepassen op het backing-veld
   @get:	Toepassen op de getter van de eigenschap
   @set:	Toepassen op de setter van de eigenschap
   @param:	Toepassen op de parameter van de constructor
   @setparam:	Toepassen op de parameter van de setter
   @delegate:	Toepassen op de instantie van de gedelegeerde eigenschap
   @receiver:	Toepassen op het ontvangertype

   class Example(@field:Inject val dependency: Dependency) {
       // @field:Inject wordt toegepast op het veld 'dependency'
   }
   

4. Aankondiging van aangepaste annotaties: Eigen annotaties worden gedeclareerd met het sleutelwoord annotation class. Parameters van de annotatie kunnen primitieve types, strings, klassen (KClass), enumeraties, andere annotaties of arrays van deze types zijn.

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

5. Meta-annotaties: Annotaties kunnen worden gemarkeerd met meta-annotaties die hun gedrag en toepasbaarheid bepalen.

   • @Target: Geeft aan welke elementen geannoteerd kunnen worden.
   • @Retention: Geeft aan op welk levensfase de annotatie aanwezig is (SOURCE, BINARY, RUNTIME).
   • @Repeatable: Staat toe dat de annotatie meerdere keren op hetzelfde element wordt toegepast.
   • @MustBeDocumented: Geeft aan dat de annotatie deel moet uitmaken van de openbare API die door de documentatietool wordt gegenereerd.

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

Annotaties worden in Kotlin veel gebruikt voor integratie met JVM-frameworks (Spring, Android), serialisatie (Kotlinx.serialization), testen (JUnit) en het maken van eigen bibliotheken gebaseerd op meta-informatie.