Pattern reified pratici: parsing, DI e serializzazione
Applichi i generics reified al parsing JSON, alla risoluzione delle dipendenze e agli helper per la reflection.
Pattern reified pratici: parsing, DI e serializzazione è 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.
I tre principali casi d'uso
I parametri di tipo reified sono particolarmente utili in tre pattern ricorrenti di Kotlin: parsing di JSON e dati, injection delle dipendenze e helper per la serializzazione. Ognuno elimina la necessità di passare argomenti ::class.java ripetitivi.
Pattern 1 — Parsing type-safe del JSON
È possibile racchiudere Gson o Jackson in un'estensione reified, così il chiamante non deve mai passare esplicitamente un Class:
inline fun <reified T> String.parseJson(): T =
Gson().fromJson(this, T::class.java)
val user: User = jsonString.parseJson()Parsing di collezioni
Per analizzare una lista generica è necessario un TypeToken. Con reified è possibile nascondere questa complessità:
inline fun <reified T> String.parseList(): List<T> {
val type = object : TypeToken<List<T>>() {}.type
return Gson().fromJson(this, type)
}
val users: List<User> = jsonString.parseList()Approccio con kotlinx.serialization
kotlinx.serialization usa già reified internamente. La funzione di primo livello decodeFromString si basa su serializer, che è una funzione reified inline.
val user = Json.decodeFromString<User>(jsonString)
// equivalent to: Json.decodeFromString(serializer<User>(), jsonString)Pattern 2 — Service Locator / DI
Un semplice service locator può risolvere le dipendenze in base al tipo, senza che il chiamante debba passare una KClass:
object ServiceLocator {
val registry = mutableMapOf<KClass<*>, Any>()
inline fun <reified T : Any> get(): T =
registry[T::class] as? T ?: error("No binding for ${T::class}")
inline fun <reified T : Any> bind(instance: T) {
registry[T::class] = instance
}
}Recuperare un ViewModel in Android
Il pattern reified più comune in Android:
inline fun <reified VM : ViewModel> ComponentActivity.viewModel(): VM =
ViewModelProvider(this)[VM::class.java]
// Usage
val vm: MyViewModel by lazy { viewModel() }Pattern 3 — Helper per il casting sicuro
Un helper reified per il casting con fallback è più pulito rispetto a usare as? esplicitamente ovunque:
inline fun <reified T> Any?.safeCast(): T? = this as? T
val name: String? = someAny.safeCast<String>()Controllare il tipo delle collezioni
Lo standard filterIsInstance è il filtro canonico per le collezioni basato su reified. È possibile costruirvi sopra varianti di livello più alto:
inline fun <reified T> List<Any>.onlyInstancesOf(block: (T) -> Unit) =
filterIsInstance<T>().forEach(block)
items.onlyInstancesOf<Button> { it.setEnabled(true) }Registrare i listener degli eventi in base al tipo
Un event bus che esegue il dispatch in base al tipo diventa più pratico con reified:
class EventBus {
val handlers = mutableMapOf<KClass<*>, (Any) -> Unit>()
inline fun <reified E : Any> on(noinline handler: (E) -> Unit) {
handlers[E::class] = { handler(it as E) }
}
fun post(event: Any) = handlers[event::class]?.invoke(event)
}Combinare reified con le funzioni di estensione
Le funzioni di estensione reified su receiver generici rendono le API più fluide, mantenendo al contempo la sicurezza dei tipi:
inline fun <reified T : Any> SharedPreferences.get(key: String, default: T): T = when (T::class) {
Int::class -> getInt(key, default as Int) as T
String::class -> getString(key, default as String) as T
Boolean::class -> getBoolean(key, default as Boolean) as T
else -> error("Unsupported type ${T::class}")
}Limiti da tenere a mente
Ricordi: reified funziona solo nelle funzioni inline. Le classi e le interfacce non possono avere parametri di tipo reified. Se è necessario disporre delle informazioni sul tipo a runtime in una classe, è preferibile memorizzare una proprietà KClass.
Testare gli helper reified
Le funzioni reified sono semplici da testare: nei test di unità è sufficiente chiamarle con argomenti di tipo concreti e verificare il tipo e il valore dell'output. Non è necessario fare mocking dei riferimenti alle classi.
val result: List<String> = """["a","b","c"]""".parseList<String>()
assertEquals(listOf("a","b","c"), result)Verifica rapida
Quale affermazione sulle funzioni reified è corretta?
Riepilogo: pattern reified pratici
Pattern chiave:
- Parsing del JSON: nascondere gli argomenti Class/TypeToken
- DI/Service Locator: risolvere in base al tipo senza parametri KClass
- Casting sicuro e filtraggio delle collezioni
- Dispatch dell'event bus in base al tipo di evento
- SharedPreferences / archivi chiave-valore tipizzati
Impara Kotlin con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 51
- Lezioni
- 203
Domande Frequenti
La lezione «Pattern reified pratici: parsing, DI e serializzazione» è gratuita?
Sì — il testo completo di «Pattern reified pratici: parsing, DI e serializzazione» è 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 «Pattern reified pratici: parsing, DI e serializzazione»?
Applichi i generics reified al parsing JSON, alla risoluzione delle dipendenze e agli helper per la reflection. 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 «Pattern reified pratici: parsing, DI e serializzazione»?
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
- Funzioni inline: eliminare l'overhead delle lambda
- Modificatori noinline e crossinline
- Parametri di tipo reified: accedere a T a runtime
- Pattern reified pratici: parsing, DI e serializzazione