Стандартные сериализаторы: JSON

func Marshal(v interface{}) ([]byte, error) 

package main

import (
    "encoding/json"
    "net/http"
)

type Visitor struct {
    ID      int
    Name    string
    Phones  []string
    Company string
}

var visitors = map[string]Visitor{
    "1": {
        ID:   1,
        Name: "Guest",
        Phones: []string{
            `789-673-56-90`,
            `612-934-77-23`,
        }},
}

func JSONHandler(w http.ResponseWriter, req *http.Request) {
    id := req.URL.Query().Get("id")
    resp, err := json.Marshal(visitors[id])
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    w.Write(resp)
}

func main() {
    http.ListenAndServe("localhost:8080", http.HandlerFunc(JSONHandler))
} 

type Visitor struct {
    ID      int      `json:"id"`
    Name    string   `json:"name,omitempty"`
    Phones  []string `json:"phones,omitempty"`
    Company string   `json:"company,omitempty"`
} 

func Unmarshal(data []byte, v interface{}) error 

func JSONHandler(w http.ResponseWriter, req *http.Request) {
    var id string

    if req.Method == http.MethodPost {
        var visitor Visitor
        var buf bytes.Buffer
        // читаем тело запроса
        _, err := buf.ReadFrom(req.Body)
        if err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        // десериализуем JSON в Visitor
        if err = json.Unmarshal(buf.Bytes(), &visitor); err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        id = strconv.Itoa(visitor.ID)
        // добавляем в мапу
        visitors[id] = visitor
    } else {
        id = req.URL.Query().Get("id")
    }
    resp, err := json.Marshal(visitors[id])
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    w.Write(resp)
} 

func main() {
    go func() {
        time.Sleep(time.Second)
        http.Post(`http://localhost:8080`, `application/json`,
      // ключи указаны в разных регистрах, но данные сконвертируются правильно
            bytes.NewBufferString(`{"ID": 10, "NaMe": "Gopher", "company": "Don't Panic"}`))
    }()
    http.ListenAndServe("localhost:8080", http.HandlerFunc(JSONHandler))
} 

func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) 

type Marshaler interface {
    MarshalJSON() ([]byte, error)
}

type Unmarshaler interface {
    UnmarshalJSON([]byte) error
} 

// MarshalJSON реализует интерфейс json.Marshaler.
func (v Visitor) MarshalJSON() ([]byte, error) {
    // чтобы избежать рекурсии при json.Marshal, объявляем новый тип
    type VisitorAlias Visitor

    aliasValue := struct {
        VisitorAlias
        // переопределяем поле внутри анонимной структуры
        ID string `json:"id"`
    }{
        // встраиваем значение всех полей изначального объекта (embedding)
        VisitorAlias: VisitorAlias(v),
        // задаём значение для переопределённого поля
        ID: strconv.Itoa(v.ID),
    }

    return json.Marshal(aliasValue) // вызываем стандартный Marshal
} 

// UnmarshalJSON реализует интерфейс json.Unmarshaler.
func (v *Visitor) UnmarshalJSON(data []byte) (err error) {
    // чтобы избежать рекурсии при json.Unmarshal, объявляем новый тип
    type VisitorAlias Visitor

    aliasValue := &struct {
        *VisitorAlias
        // переопределяем поле внутри анонимной структуры
        ID string `json:"id"`
    }{
        VisitorAlias: (*VisitorAlias)(v),
    }
    // вызываем стандартный Unmarshal
    if err = json.Unmarshal(data, aliasValue); err != nil {
        return
    }
    v.ID, err = strconv.Atoi(aliasValue.ID)
    return
} 

type (
    // MyType использует динамическую типизацию своих полей
    MyType struct {
        // Type задаёт тип объекта поля Value
        Type int `json:"type"`
        // Value содержит объект типа {TypeA, TypeB}
        Value interface{} `json:"value"`
    }

    // TypeA используется полем Value типа MyType при Type == 1
    TypeA struct {
        StrValue string `json:"str_value"`
    }

    // TypeB используется полем Value типа MyType при Type == 2
    TypeB struct {
        FloatValue float32 `json:"float_value"`
    }
) 

func main() {
    tOrig := MyType{
        Type: 1,
        Value: TypeA{
            StrValue: "some_string",
        },
    }

    tOrigJSON, _ := json.MarshalIndent(tOrig, "", "  ")
    fmt.Printf("tOrigJSON:\n%s\n", string(tOrigJSON))

    tCopy := MyType{}
    json.Unmarshal(tOrigJSON, &tCopy)
    fmt.Printf("tCopy Go: %+v\n", tCopy)
    fmt.Printf("tCopy.Value Go: %+v\n", tCopy.Value)
} 

func (t *MyType) UnmarshalJSON(data []byte) error {
    // чтобы избежать рекурсии при json.Unmarshal, объявляем новый тип
    type MyTypeAlias MyType

    // переопределяем поле внутри анонимной структуры
    aliasValue := &struct {
        *MyTypeAlias
        Value json.RawMessage `json:"value"`
    }{
        // встраиваем указатель на целевой объект для заполнения его полей (кроме Value)
        MyTypeAlias: (*MyTypeAlias)(t),
    }
    if err := json.Unmarshal(data, aliasValue); err != nil {
        return err
    }

    // создаём экземпляр конкретного типа
    switch t.Type {
    case 1:
        t.Value = &TypeA{}
    case 2:
        t.Value = &TypeB{}
    }
    if t.Value != nil {
        // производим Unmarshal json.RawMessage значения
        if err := json.Unmarshal(aliasValue.Value, t.Value); err != nil {
            return fmt.Errorf("value of type (%T): unmarshal: %w", t.Value, err)
        }
    }

    return nil
} 

var buf bytes.Buffer
var v MyType

jsonEncoder := json.NewEncoder(&buf)
jsonEncoder.Encode(v)

jsonDecoder := json.NewDecoder(&buf)
jsonDecoder.Decode(&v) 

func JSONHandler(w http.ResponseWriter, req *http.Request) {
    var id string

    if req.Method == http.MethodPost {
        var visitor Visitor
        
        if err := json.NewDecoder(req.Body).Decode(&visitor); err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        id = strconv.Itoa(visitor.ID)
        // добавляем в мапу
        visitors[id] = visitor
    } 
    // код ниже остался без изменений
    // ...
}