Kotlin Academy · Lezione

Validazione e mapping basati sulla reflection

Costruisca un semplice validatore o object mapper usando la reflection guidata dalle annotazioni.

Validazione e mapping basati sulla reflection è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Quale problema risolve questo pattern

La convalida basata sulla reflection legge a runtime le annotazioni dalle proprietà di una classe e applica automaticamente le regole di convalida, senza controlli manuali per ogni campo. La stessa tecnica alimenta i mapper ORM che convertono gli oggetti in righe del database e viceversa.

L'annotazione Validate

Definisca un'annotazione mantenuta a runtime e applicabile alle proprietà:

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.PROPERTY)
annotation class Validate(
    val minLength: Int = 0,
    val maxLength: Int = Int.MAX_VALUE,
    val pattern: String = ""
)

Annotazione di una data class

Applichi @Validate alle proprietà della data class. Il validatore le esaminerà a runtime:

data class UserForm(
    @Validate(minLength = 2, maxLength = 50) val name: String,
    @Validate(pattern = "^[\\w.]+@[\\w]+\\.[a-z]{2,}$") val email: String,
    @Validate(minLength = 8) val password: String
)

La funzione del validatore

Utilizzi KClass.declaredMemberProperties per scorrere le proprietà, trovare le annotazioni e raccogliere gli errori:

fun validate(obj: Any): List<String> {
    val errors = mutableListOf<String>()
    for (prop in obj::class.declaredMemberProperties) {
        val ann = prop.findAnnotation<Validate>() ?: continue
        val value = (prop as KProperty1<Any, *>).get(obj)?.toString() ?: ""
        if (value.length < ann.minLength) errors += "${prop.name}: too short"
        if (value.length > ann.maxLength) errors += "${prop.name}: too long"
        if (ann.pattern.isNotEmpty() && !value.matches(Regex(ann.pattern)))
            errors += "${prop.name}: invalid format"
    }
    return errors
}

Esecuzione del validatore

Chiami validate() passando un oggetto con annotazioni. La funzione restituisce un elenco di messaggi di errore; un elenco vuoto indica che l'oggetto è valido:

val form = UserForm("A", "not-an-email", "short")
val errors = validate(form)
errors.forEach(::println)
// name: too short
// email: invalid format
// password: too short

Mappatura da oggetto a Map con @Column

Un altro pattern di reflection mappa un oggetto in una Map utilizzando un'annotazione @Column per fornire i nomi delle colonne:

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.PROPERTY)
annotation class Column(val name: String)

fun toMap(obj: Any): Map<String, Any?> =
    obj::class.declaredMemberProperties
        .mapNotNull { prop ->
            val col = prop.findAnnotation<Column>() ?: return@mapNotNull null
            col.name to (prop as KProperty1<Any, *>).get(obj)
        }.toMap()

Utilizzo del mapper

Annoti la data class e chiami toMap() per ottenere una mappa indicizzata per nome di colonna, pronta per un'istruzione INSERT:

data class User(
    @Column("user_name") val name: String,
    @Column("user_email") val email: String
)

val user = User("Alice", "alice@example.com")
println(toMap(user))
// {user_name=Alice, user_email=alice@example.com}

Memorizzazione nella cache dei risultati della reflection

Le scansioni tramite reflection sono costose. Memorizzi nella cache, all'avvio, la mappatura tra proprietà e annotazioni utilizzando una ConcurrentHashMap indicizzata per KClass:

val cache = ConcurrentHashMap<KClass<*>, List<Pair<KProperty1<Any,*>, Column>>>()

fun columnsOf(klass: KClass<*>) = cache.getOrPut(klass) {
    klass.declaredMemberProperties
        .mapNotNull { p ->
            p.findAnnotation<Column>()?.let { (p as KProperty1<Any,*>) to it }
        }
}

Combinazione di validazione e mappatura

Può applicare più annotazioni alla stessa proprietà ed elaborarle separatamente. Prima esegua la validazione, poi la mappatura — oppure esegua entrambe in un'unica passata raccogliendo ogni tipo di annotazione:

data class Product(
    @Validate(minLength = 1) @Column("product_name") val name: String,
    @Column("price") val price: Double
)

Limitazioni

La validazione basata sulla reflection è potente, ma comporta alcuni compromessi: aggiunge overhead a runtime, dipende dalla conservazione delle annotazioni e non può rilevare gli errori in fase di compilazione. Per una validazione critica per le prestazioni o sicura a compile time, valuti invece il codice generato da KSP.

Quando utilizzare questo pattern

La validazione basata sulla reflection è particolarmente efficace nel codice dei framework che deve gestire classi definite arbitrariamente dagli utenti: ORM, serializzatori, validatori di moduli e binder di configurazione. Il codice dell'applicazione che controlla i propri tipi dovrebbe preferire una validazione esplicita, per maggiore velocità e chiarezza.

Verifica rapida

Quale politica di conservazione delle annotazioni è necessaria affinché un'annotazione di validazione possa essere letta a runtime?

Riepilogo: validazione e mappatura basate sulla reflection

Punti chiave:

Dichiari annotazioni mantenute a runtime e applicabili alle proprietà
Utilizzi declaredMemberProperties + findAnnotation per gestire la validazione o la mappatura
Memorizzi i risultati nella cache per ogni KClass per evitare l'overhead ripetuto della reflection
Applichi più annotazioni a una proprietà per combinare i comportamenti
Valuti KSP come alternativa in fase di compilazione nei percorsi critici per le prestazioni

Domande Frequenti

La lezione «Validazione e mapping basati sulla reflection» è gratuita?

Sì — il testo completo di «Validazione e mapping basati sulla reflection» è 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 «Validazione e mapping basati sulla reflection»?

Costruisca un semplice validatore o object mapper usando la reflection guidata dalle annotazioni. 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 4 di 4.

Quanto tempo richiede la lezione «Validazione e mapping basati sulla reflection»?

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

Reflection di Kotlin: KClass, KFunction, KProperty
Creare e applicare annotazioni personalizzate
Leggere le annotazioni a runtime
Validazione e mapping basati sulla reflection

← Torna a Kotlin Academy