0Pricing
Kotlin Academy · Lekcja

Praktyczne wzorce reified: parsowanie, DI i serializacja

Stosuj generyki reified do parsowania JSON, rozwiązywania zależności i pomocniczych funkcji refleksji.

Praktyczne wzorce reified: parsowanie, DI i serializacja to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Trzy główne przypadki użycia

Reifikowane parametry typu doskonale sprawdzają się w trzech powtarzających się wzorcach języka Kotlin: parsowaniu JSON i danych, wstrzykiwaniu zależności oraz pomocnikach serializacji. Każdy z nich eliminuje konieczność dodawania argumentów ::class.java.

Wzorzec 1 — bezpieczne typowo parsowanie JSON

Można opakować Gson lub Jackson w reifikowane rozszerzenie, aby wywołujący nigdy nie musieli jawnie przekazywać elementu Class:

inline fun <reified T> String.parseJson(): T =
    Gson().fromJson(this, T::class.java)

val user: User = jsonString.parseJson()

Parsowanie kolekcji

Parsowanie listy generycznej wymaga użycia elementu TypeToken. Dzięki reified można ukryć tę złożoność:

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()

Podejście kotlinx.serialization

kotlinx.serialization już wewnętrznie używa reified. Funkcja najwyższego poziomu decodeFromString() korzysta z serializer(), która jest funkcją reified inline.

val user = Json.decodeFromString<User>(jsonString)
// equivalent to: Json.decodeFromString(serializer<User>(), jsonString)

Wzorzec 2 — Service Locator / DI

Prosty service locator może rozwiązywać zależności na podstawie typu, bez wymagania od wywołujących przekazywania elementu 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
    }
}

Pobieranie ViewModel w systemie Android

Najczęściej spotykany wzorzec reified w systemie Android:

inline fun <reified VM : ViewModel> ComponentActivity.viewModel(): VM =
    ViewModelProvider(this)[VM::class.java]

// Usage
val vm: MyViewModel by lazy { viewModel() }

Wzorzec 3 — pomocnik bezpiecznego rzutowania

Pomocnik reified do rzutowania z wartością zastępczą jest czytelniejszy niż jawne używanie as? w każdym miejscu:

inline fun <reified T> Any?.safeCast(): T? = this as? T

val name: String? = someAny.safeCast<String>()

Sprawdzanie typów kolekcji

Standardowa funkcja filterIsInstance() jest typowym przykładem reifikowanego filtrowania kolekcji. Można na jej podstawie tworzyć warianty wyższego poziomu:

inline fun <reified T> List<Any>.onlyInstancesOf(block: (T) -> Unit) =
    filterIsInstance<T>().forEach(block)

items.onlyInstancesOf<Button> { it.setEnabled(true) }

Rejestrowanie odbiorników zdarzeń według typu

Magistrala zdarzeń rozsyłająca zdarzenia według typu staje się wygodniejsza dzięki 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)
}

Łączenie reified z funkcjami rozszerzającymi

Reifikowane funkcje rozszerzające dla generycznych odbiorników nadają interfejsom API płynny charakter, zachowując bezpieczeństwo typów:

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}")
}

Ograniczenia, o których należy pamiętać

Proszę pamiętać: reified działa tylko w funkcjach inline. Klasy i interfejsy nie mogą mieć reifikowanych parametrów typu. Jeśli klasa potrzebuje informacji o typie w czasie działania, należy zamiast tego przechowywać właściwość KClass.

Testowanie pomocników reified

Funkcje reified są łatwe do testowania — w testach jednostkowych należy wywoływać je z konkretnymi argumentami typu i sprawdzać typ oraz wartość wyniku. Mockowanie referencji do klas nie jest potrzebne.

val result: List<String> = """["a","b","c"]""".parseList<String>()
assertEquals(listOf("a","b","c"), result)

Szybkie sprawdzenie

Które stwierdzenie dotyczące funkcji reified jest poprawne?

Podsumowanie: praktyczne wzorce reified

Najważniejsze wzorce:

  • Parsowanie JSON: ukrywanie argumentów Class/TypeToken
  • DI/Service Locator: rozwiązywanie zależności na podstawie typu bez parametrów KClass
  • Bezpieczne rzutowanie i filtrowanie kolekcji
  • Rozsyłanie zdarzeń w magistrali zdarzeń według typu zdarzenia
  • SharedPreferences / typowane magazyny par klucz-wartość

Często zadawane pytania

Czy lekcja „Praktyczne wzorce reified: parsowanie, DI i serializacja” jest bezpłatna?

Tak — pełny tekst „Praktyczne wzorce reified: parsowanie, DI i serializacja” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Praktyczne wzorce reified: parsowanie, DI i serializacja”?

Stosuj generyki reified do parsowania JSON, rozwiązywania zależności i pomocniczych funkcji refleksji. Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Praktyczne wzorce reified: parsowanie, DI i serializacja”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Funkcje inline: eliminowanie narzutu lambd
  2. Modyfikatory noinline i crossinline
  3. Parametry typów reified: dostęp do T w czasie działania
  4. Praktyczne wzorce reified: parsowanie, DI i serializacja
← Powrót do Kotlin Academy