Quali sono le caratteristiche del lavoro con le annotazioni in Kotlin?

Le annotazioni in Kotlin sono simili a quelle in Java, ma presentano alcune caratteristiche:

• Sintassi: Le annotazioni vengono posizionate prima dell'elemento a cui si applicano, senza il simbolo @.
• Utilizzo in runtime: Per impostazione predefinita, le annotazioni non vengono conservate in runtime. Per conservarle, è necessario usare la meta-annotazione @Retention(AnnotationRetention.RUNTIME).
• Applicazione al tipo: Le annotazioni possono essere applicate non solo a classi, funzioni e proprietà, ma anche ai tipi (ad esempio, @NonNull String). Per questo si usa typealias.
• Annotazione dei costruttori: Per annotare il costruttore principale di una classe, si usa la parola chiave constructor. Per i costruttori secondari, l'annotazione viene posta direttamente prima di essi.
• Annotazione di proprietà e dei loro accessor: Le annotazioni possono essere applicate alla proprietà stessa, al suo getter (@get:) o al suo setter (@set:).
• Annotazione dei parametri del costruttore per le proprietà: Le annotazioni applicate ai parametri del costruttore principale, che sono anche proprietà, annotano queste proprietà. Per annotare il parametro stesso, si usa @param:.
• Annotazione dei parametri di funzioni e metodi: Le annotazioni vengono poste direttamente prima del parametro.
• Lavoro con le annotazioni in reflection: La reflection in Kotlin (kotlin-reflect) permette di ottenere informazioni sulle annotazioni in runtime se si usa @Retention(AnnotationRetention.RUNTIME).
• Ambito di applicazione: Le annotazioni possono avere una dichiarazione di destinazione tramite prefissi:
  • @file: - per il file
  • @property: - per la proprietà
  • @field: - per il campo generato per la proprietà
  • @get: - per il getter della proprietà
  • @set: - per il setter della proprietà
  • @param: - per il parametro del costruttore
  • @setparam: - per il parametro del setter della proprietà
  • @delegate: - per il campo delegato
  • @use-site: - per indicare il sito di utilizzo quando non è possibile specificare chiaramente l'obiettivo

Esempio di creazione e utilizzo di un'annotazione:

// Definizione dell'annotazione
@Retention(AnnotationRetention.RUNTIME)
annotation class MyAnnotation(val value: String)

// Utilizzo dell'annotazione
@MyAnnotation("Hello")
class MyClass {

    @get:MyAnnotation("World")
    val myProperty: String = "some value"

    constructor(@param:MyAnnotation("ConstructorParam") param: Int) {
        // ...
    }

    fun myFunction(@MyAnnotation("FunctionParam") param: String) {
        // ...
    }
}