Bagaimana untuk Unmarshal Dynamic JSON dalam Go tanpa Medan Pemegang Tempat Generik?

Menyahmarshalling Dynamic JSON Berdasarkan Kunci Jenis

Pengenalan

Menyahmarshalling data JSON ke dalam struct Go boleh menjadi tugas yang mudah. Walau bagaimanapun, apabila berurusan dengan dokumen JSON yang mengandungi struktur data dinamik, di mana jenis medan boleh berbeza-beza, prosesnya boleh menjadi lebih kompleks. Artikel ini meneroka penyelesaian kepada cabaran ini tanpa memperkenalkan medan pemegang tempat generik.

Definisi Masalah

Pertimbangkan spesifikasi JSON berikut:

{
  "some_data": "foo",
  "dynamic_field": { "type": "A", "name": "Johnny" },
  "other_data": "bar"
}

{
  "some_data": "foo",
  "dynamic_field": { "type": "B", "address": "Somewhere" },
  "other_data": "bar"
}

Kedua-dua dokumen JSON hendaklah tidak dikawal ke dalam struct Go yang sama:

type BigStruct struct {
  SomeData     string    `json:"some_data"`
  DynamicField Something `json:"dynamic_field"`
  OtherData    string    `json:"other_data"`
}

The soalan utama ialah: bagaimana untuk mencipta jenis Sesuatu dan melaksanakan logik unmarshalling?

Penyelesaian: Menggunakan Antara Muka dengan Kaedah UnmarshalJSON Tersuai

Penyelesaian melibatkan mencipta antara muka untuk jenis Sesuatu:

type Something interface {
  GetType() string
}

Seterusnya, tentukan jenis struct khusus yang melaksanakan Sesuatu antara muka:

type BaseDynamicType struct {
  Type string `json:"type"`
}

type DynamicTypeA struct {
  BaseDynamicType
  Name string `json:"name"`
}

type DynamicTypeB struct {
  BaseDynamicType
  Address string `json:"address"`
}

Kaedah antara muka DynamicType membenarkan data JSON dipisahkan ke dalam struktur yang sesuai:

func (d *DynamicType) UnmarshalJSON(data []byte) error {
    var typ struct {
        Type string `json:"type"`
    }
    if err := json.Unmarshal(data, &typ); err != nil {
        return err
    }
    switch typ.Type {
    case "A":
        d.Value = new(TypeA)
    case "B":
        d.Value = new(TypeB)
    }
    return json.Unmarshal(data, d.Value)
}

Kaedah ini memeriksa data JSON dan mencipta contoh TypeA atau TypeB mengikut keperluan.

Melaksanakan UnmarshalJSON pada BigStruct

Akhir sekali, laksanakan kaedah UnmarshalJSON pada jenis BigStruct:

func (b *BigStruct) UnmarshalJSON(data []byte) error {
    var tmp BigStruct // avoids infinite recursion
    return json.Unmarshal(data, &tmp)
}

Kaedah ini menggunakan jenis BigStruct sementara untuk mengelakkan rekursi dan membenarkan medan dinamik tidak dikawal menggunakan jenis DynamicType yang sesuai berdasarkan medan jenis dalam JSON data.

Kesimpulan

Penyelesaian ini menyediakan cara yang bersih dan cekap untuk membongkar data JSON dinamik tanpa memerlukan medan pemegang tempat generik tambahan. Dengan menggunakan antara muka dan melaksanakan kaedah UnmarshalJSON tersuai, struct Go boleh menyesuaikan diri dengan struktur data dinamik dalam input JSON.

Atas ialah kandungan terperinci Bagaimana untuk Unmarshal Dynamic JSON dalam Go tanpa Medan Pemegang Tempat Generik?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!