Go Academy · Aula

Reflexão prática: serializadores

Crie um serializador simples, semelhante a JSON, com reflect

Reflexão prática: serializadores é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Visão geral de um serializador JSON personalizado

Criar um serializador personalizado com reflexão demonstra uma aplicação prática da reflexão: percorrer campos de struct, ler tags, acessar valores e construir a saída — a mesma abordagem usada internamente por encoding/json.

Conversão simples de struct em mapa

Converta uma struct em um map[string]any usando reflexão:

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
}

Tratamento de ponteiros

Remova a referência dos campos ponteiro antes de ler seus valores:

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

Tratamento de structs aninhadas

Processe recursivamente os campos de structs aninhadas:

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

Suporte a omitempty

Ignore campos com valor zero se a tag incluir "omitempty":

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

Mapa para struct (desserializador)

Preencha uma struct a partir de um mapa, associando as chaves do mapa às tags dos campos:

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

Coerção de tipos

Os valores de mapas provenientes de JSON geralmente são float64 para números. Converta-os para o tipo do campo de destino ao definir o valor:

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

Armazenamento em cache dos metadados dos campos

Armazene em cache o mapeamento de campo para tag em um sync.Map indexado por reflect.Type para evitar reflexão repetida em cada chamada de serialização.

Alternativa de geração de código

Para caminhos críticos para o desempenho, gere serializadores específicos para cada tipo com ferramentas como easyjson ou ffjson. Elas evitam completamente a reflexão em tempo de execução.

Quando criar serializadores personalizados

Serializadores personalizados são úteis para: formatos que não sejam JSON (BSON, Avro, CSV), regras de codificação personalizadas ou requisitos rigorosos de desempenho. Para a maioria dos casos de uso, encoding/json é suficiente.

Testando o serializador

Teste de ida e volta: serialize uma estrutura em um mapa, desserialize-a novamente e verifique se os valores correspondem aos originais:

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

Verificação rápida

Por que o armazenamento em cache dos metadados dos campos é importante ao criar um serializador baseado em reflexão?

Recapitulação: serializadores baseados em reflexão

Pontos principais:

Itere pelos campos com NumField/Field; leia as tags com Tag.Get
Trate ponteiros, estruturas aninhadas e valores zero
Armazene os metadados dos campos em cache usando sync.Map para obter melhor desempenho
Use geração de código para obter a maior vazão

Perguntas Frequentes

A aula “Reflexão prática: serializadores” é grátis?

Sim — o texto completo de “Reflexão prática: serializadores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Reflexão prática: serializadores”?

Crie um serializador simples, semelhante a JSON, com reflect Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Reflexão prática: serializadores”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy