0Pricing
Kotlin Academy · Lezione

Creare e applicare annotazioni personalizzate

Definisca annotazioni con politiche di conservazione e le applichi a classi, funzioni e proprietà.

Creare e applicare annotazioni personalizzate è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Perché usare annotazioni personalizzate?

Le annotazioni sono metadati associati a dichiarazioni (classi, funzioni, proprietà e parametri). Le annotazioni personalizzate permettono di contrassegnare il codice per l'elaborazione da parte di framework, strumenti di build (KSP/KAPT) o della propria logica a runtime.

Dichiarare un'annotazione

Usi la parola chiave annotation class. Le classi annotazione possono avere parametri del costruttore (solo tipi primitivi, String, KClass, enumerazioni, altre annotazioni o array di questi tipi):

annotation class Validate(val minLength: Int = 1, val maxLength: Int = 255)

Meta-annotazioni: @Target

@Target limita i contesti in cui l'annotazione può essere usata. Target comuni: CLASS, FUNCTION, PROPERTY, FIELD, VALUE_PARAMETER, CONSTRUCTOR.

@Target(AnnotationTarget.PROPERTY, AnnotationTarget.VALUE_PARAMETER)
annotation class Validate(val minLength: Int = 1, val maxLength: Int = 255)

@Retention: quando è disponibile l'annotazione?

@Retention controlla il ciclo di vita dell'annotazione:

  • SOURCE — viene scartata dopo la compilazione
  • BINARY — viene memorizzata nel file .class, ma non è visibile tramite reflection
  • RUNTIME — viene memorizzata ed è visibile a runtime (impostazione predefinita per la maggior parte dei casi d'uso)
@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.PROPERTY)
annotation class Validate(val minLength: Int = 1)

@Repeatable: applicare più volte la stessa annotazione

Per impostazione predefinita, un'annotazione può essere applicata una sola volta a ogni dichiarazione. La contrassegni con @Repeatable per consentirne più applicazioni:

@Repeatable
@Target(AnnotationTarget.FUNCTION)
annotation class Role(val name: String)

Annotare costruttori e parametri

È possibile annotare i parametri del costruttore e le proprietà del costruttore primario. Usi i target use-site @field:, @get: o @param: per controllare quale elemento riceve l'annotazione:

data class User(
    @field:Validate(minLength = 2) val name: String,
    @field:Validate(minLength = 0, maxLength = 120) val email: String
)

Target use-site

Kotlin genera più elementi di bytecode da una singola proprietà (campo, getter, setter e parametro). I target use-site specificano quale di questi riceve l'annotazione:

  • @field: il backing field
  • @get: il getter
  • @set: il setter
  • @param: il parametro del costruttore

Annotare le classi

Le annotazioni su una classe sono utili per contrassegnarla per l'elaborazione da parte di un framework (ad esempio, per indicare che una classe è serializzabile, iniettabile o parte di un modulo specifico):

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class Repository

@Repository
class UserRepository

@MustBeDocumented

L'aggiunta di @MustBeDocumented garantisce che l'annotazione compaia nella documentazione API generata. La usi per le annotazioni che fanno parte del contratto della sua API pubblica.

@MustBeDocumented
@Target(AnnotationTarget.CLASS)
annotation class PublicApi(val since: String)

Parametri delle annotazioni: valori predefiniti e array

I parametri possono avere valori predefiniti e accettare array usando la parola chiave vararg o tipi array espliciti:

annotation class Roles(vararg val value: String)

@Roles("ADMIN", "EDITOR")
class AdminPanel

Parametri KClass nelle annotazioni

Le annotazioni possono fare riferimento a tipi di classe tramite KClass:

annotation class Serializer(val using: KClass<out Any>)

@Serializer(using = GsonAdapter::class)
class Event

Verifica rapida

Quale valore di @Retention rende un'annotazione personalizzata accessibile tramite la reflection di Kotlin a runtime?

Riepilogo: annotazioni personalizzate

Concetti chiave:

  • Dichiarare con annotation class; i parametri sono limitati a tipi primitivi, String, KClass, enumerazioni e array
  • @Target — dove può essere applicata
  • @Retention — quando è disponibile (usare RUNTIME per la reflection)
  • @Repeatable — consente più applicazioni sulla stessa dichiarazione
  • I target use-site (@field:, @get: ecc.) controllano quale elemento di bytecode riceve l'annotazione

Domande Frequenti

La lezione «Creare e applicare annotazioni personalizzate» è gratuita?

Sì — il testo completo di «Creare e applicare annotazioni personalizzate» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Creare e applicare annotazioni personalizzate»?

Definisca annotazioni con politiche di conservazione e le applichi a classi, funzioni e proprietà. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Creare e applicare annotazioni personalizzate»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Reflection di Kotlin: KClass, KFunction, KProperty
  2. Creare e applicare annotazioni personalizzate
  3. Leggere le annotazioni a runtime
  4. Validazione e mapping basati sulla reflection
← Torna a Kotlin Academy