Bagaimana untuk Menyesuaikan JSON Unmarshaling dengan Reflection dalam Go?

Menyesuaikan JSON Unmarshaling dengan Reflection

In Go, unmarshaling JSON ke dalam struct ialah proses yang mudah. Walau bagaimanapun, apabila berurusan dengan medan yang mempunyai teg tersuai, seperti json:"some_field", mekanisme unmarshalling standard mungkin tidak mencukupi.

Satu pendekatan untuk mengendalikan senario ini ialah menggunakan refleksi. Dengan memeriksa medan struct menggunakan refleksi, kami boleh menyemak sama ada medan mempunyai teg tertentu dan jika ya, kendalikan unmarshallingnya dengan sewajarnya.

Dalam kes khusus ini, kami ingin memastikan bahawa medan dengan tag json adalah unmarshalled ke dalam medan rentetan apa adanya. Ini membolehkan kami mengendalikan objek atau tatasusunan JSON dalam struct Go kami.

Senario Contoh

Pertimbangkan data JSON dan struct Go berikut:

<code class="json">{
  "I": 3,
  "S": {
    "phone": {
      "sales": "2223334444"
    }
  }
}</code>

<code class="go">type A struct {
    I int64
    S string `sql:"type:json"`
}</code>

Matlamat kami ialah untuk membuka medan "S" sebagai rentetan, mengekalkan struktur JSON bersarangnya.

Penyelesaian Menggunakan Refleksi

Kod berikut menunjukkan bagaimana untuk mencapai ini menggunakan refleksi:

<code class="go">func main() {
    a := A{}

    // Unmarshal the JSON data into a byte slice
    var data []byte

    // Iterate over the fields of the struct
    typ := reflect.TypeOf(a)
    val := reflect.ValueOf(a)
    for i := 0; i < typ.NumField(); i++ {
        f := typ.Field(i)

        // Check if the field has a "json" tag
        if f.Tag.Get("json") == "" {
            continue
        }

        // Retrieve the field value
        fv := val.Field(i)

        // Unmarshall the JSON data into the field as a string
        if err := json.Unmarshal(data, &fv); err != nil {
            log.Fatal(err)
        }
    }

    fmt.Println(a)
}</code>

Dalam pendekatan ini, kami memeriksa secara manual setiap medan struct menggunakan refleksi untuk menentukan sama ada ia mempunyai teg "json". Jika ya, kami menyahmarshal data JSON ke dalam medan sebagai rentetan.

Penyelesaian Alternatif dengan Custom Marshaler dan Unmarshaler

Pilihan lain ialah melaksanakan jenis tersuai, seperti RawString, yang melaksanakan antara muka json.Marshaler dan json.Unmarshaler. Ini membolehkan lebih fleksibiliti dan kawalan ke atas proses unmarshalling.

Pendekatan ini ditunjukkan dalam kod berikut:

<code class="go">// RawString is a raw encoded JSON object.
// It implements Marshaler and Unmarshaler and can
// be used to delay JSON decoding or precompute a JSON encoding.
type RawString string

// MarshalJSON returns *m as the JSON encoding of m.
func (m *RawString) MarshalJSON() ([]byte, error) {
    return []byte(*m), nil
}

// UnmarshalJSON sets *m to a copy of data.
func (m *RawString) UnmarshalJSON(data []byte) error {
    if m == nil {
        return errors.New("RawString: UnmarshalJSON on nil pointer")
    }
    *m += RawString(data)
    return nil
}

const data = `{"i":3, "S":{"phone": {"sales": "2223334444"}}}`

type A struct {
    I int64
    S RawString `sql:"type:json"`
}

func main() {
    a := A{}
    err := json.Unmarshal([]byte(data), &a)
    if err != nil {
        log.Fatal("Unmarshal failed", err)
    }
    fmt.Println("Done", a)
}</code>

Dengan melaksanakan jenis kami sendiri, kami boleh menyesuaikan proses unmarshalling dan mengelakkan keperluan untuk refleksi, menghasilkan penyelesaian yang lebih bersih dan lebih cekap.

Atas ialah kandungan terperinci Bagaimana untuk Menyesuaikan JSON Unmarshaling dengan Reflection dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!