Go Academy · Lekcja

Refleksja w praktyce: serializatory

Tworzenie prostego serializatora podobnego do JSON za pomocą reflect

Refleksja w praktyce: serializatory to bezpłatna lekcja Go 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 Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Przegląd niestandardowego serializera JSON

Budowa niestandardowego serializera za pomocą refleksji pokazuje praktyczne zastosowanie refleksji: iterowanie po polach struktury, odczytywanie tagów, uzyskiwanie dostępu do wartości i budowanie wyniku — jest to podejście używane wewnętrznie przez encoding/json.

Prosta konwersja struktury na mapę

Konwertować strukturę na map[string]any za pomocą refleksji:

func StructToMap(v any) map[string]any {
    t := reflect.TypeOf(v)
    val := reflect.ValueOf(v)
    result := make(map[string]any, t.NumField())
    for i := 0; i < t.NumField(); i++ {
        f := t.Field(i)
        if !f.IsExported() { continue }
        key := f.Tag.Get("json")
        if key == "" { key = f.Name }
        result[key] = val.Field(i).Interface()
    }
    return result
}

Obsługa wskaźników

Przed odczytaniem wartości należy dereferencjonować pola będące wskaźnikami:

fv := val.Field(i)
if fv.Kind() == reflect.Ptr {
    if fv.IsNil() { continue }
    fv = fv.Elem()
}

Obsługa zagnieżdżonych struktur

Rekursywnie przetwarzać zagnieżdżone pola struktur:

if fv.Kind() == reflect.Struct {
    result[key] = StructToMap(fv.Interface())
    continue
}

Obsługa omitempty

Pomijać pola o wartości zerowej, jeśli tag zawiera "omitempty":

if strings.Contains(tag, "omitempty") && fv.IsZero() { continue }

Mapa do struktury (deserializator)

Wypełniać strukturę na podstawie mapy, dopasowując klucze mapy do tagów pól:

func MapToStruct(m map[string]any, dest any) {
    t := reflect.TypeOf(dest).Elem()
    v := reflect.ValueOf(dest).Elem()
    for i := 0; i < t.NumField(); i++ {
        key := t.Field(i).Tag.Get("json")
        if val, ok := m[key]; ok {
            v.Field(i).Set(reflect.ValueOf(val))
        }
    }
}

Konwersja typów

Wartości mapy pochodzące z JSON-u są często typu float64 w przypadku liczb. Podczas ustawiania należy przekonwertować je na typ docelowego pola:

if f.Type.Kind() == reflect.Int && reflect.TypeOf(val).Kind() == reflect.Float64 {
    v.Field(i).SetInt(int64(val.(float64)))
}

Buforowanie metadanych pól

Należy buforować mapowanie pól na tagi w sync.Map indeksowanej kluczem reflect.Type, aby uniknąć wielokrotnego wykonywania refleksji przy każdym wywołaniu serializacji.

Alternatywa: generowanie kodu

W przypadku ścieżek krytycznych pod względem wydajności należy generować serializery specyficzne dla typu za pomocą narzędzi takich jak easyjson lub ffjson. Pozwalają one całkowicie uniknąć refleksji w czasie działania.

Kiedy tworzyć niestandardowe serializery

Niestandardowe serializery są przydatne w przypadku formatów innych niż JSON (BSON, Avro, CSV), niestandardowych reguł kodowania lub rygorystycznych wymagań wydajnościowych. W większości zastosowań wystarcza encoding/json.

Testowanie serializera

Test round-trip: serializacja struktury do mapy, deserializacja z powrotem oraz sprawdzenie asercją, że wartości odpowiadają oryginałowi:

u := User{Name: "Alice", Age: 30}
m := StructToMap(u)
var u2 User
MapToStruct(m, &u2)
assert.Equal(t, u, u2)

Szybkie sprawdzenie

Dlaczego buforowanie metadanych pól jest ważne podczas tworzenia serializera opartego na refleksji?

Podsumowanie: serializery oparte na refleksji

Najważniejsze informacje:

Iterować po polach za pomocą NumField/Field; odczytywać tagi za pomocą Tag.Get
Obsługiwać wskaźniki, zagnieżdżone struktury i wartości zerowe
Buforować metadane pól w sync.Map, aby zwiększyć wydajność
Używać generowania kodu, aby uzyskać najwyższą przepustowość

Często zadawane pytania

Czy lekcja „Refleksja w praktyce: serializatory” jest bezpłatna?

Tak — pełny tekst „Refleksja w praktyce: serializatory” 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 Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Refleksja w praktyce: serializatory”?

Tworzenie prostego serializatora podobnego do JSON za pomocą reflect Ćwiczysz Go 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ąć Go Academy?

Nie wymagamy żadnego doświadczenia. Go 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 „Refleksja w praktyce: serializatory”?

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 Go Academy?

Tak. Każda lekcja Go 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

← Powrót do Go Academy