प्रतिबिंब के साथ JSON अनमर्शलिंग को अनुकूलित करना

गो में, JSON को एक संरचना में अनमर्शलिंग करना एक सीधी प्रक्रिया है। हालाँकि, कस्टम टैग वाले फ़ील्ड, जैसे कि json:"some_field" के साथ काम करते समय, मानक अनमर्शलिंग तंत्र पर्याप्त नहीं हो सकता है।

इस परिदृश्य को संभालने का एक तरीका प्रतिबिंब का उपयोग करना है। प्रतिबिंब का उपयोग करके संरचना के फ़ील्ड का निरीक्षण करके, हम जांच सकते हैं कि क्या किसी फ़ील्ड में एक विशिष्ट टैग है और यदि हां, तो उसके अनुसार अनमर्शलिंग को संभालें।

इस विशेष मामले में, हम यह सुनिश्चित करना चाहते हैं कि json टैग वाला एक फ़ील्ड है एक स्ट्रिंग फ़ील्ड में अनमर्शल्ड जैसा है। यह हमें हमारी गो संरचना के भीतर JSON ऑब्जेक्ट या सरणियों को संभालने की अनुमति देता है।

उदाहरण परिदृश्य

निम्नलिखित JSON डेटा और गो संरचना पर विचार करें:

{
  "I": 3,
  "S": {
    "phone": {
      "sales": "2223334444"
    }
  }
}

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

हमारा लक्ष्य "S" फ़ील्ड को एक स्ट्रिंग के रूप में अनमार्शल करना है, इसके नेस्टेड JSON संरचना को संरक्षित करना है।

प्रतिबिंब का उपयोग करके समाधान

निम्नलिखित कोड दर्शाता है कि प्रतिबिंब का उपयोग करके इसे कैसे प्राप्त किया जाए:

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 
इस दृष्टिकोण में, हम यह निर्धारित करने के लिए प्रतिबिंब का उपयोग करके संरचना के प्रत्येक क्षेत्र का मैन्युअल रूप से निरीक्षण करते हैं कि इसमें "json" टैग है या नहीं। यदि ऐसा होता है, तो हम JSON डेटा को एक स्ट्रिंग के रूप में फ़ील्ड में अनमर्शल कर देते हैं।
कस्टम मार्शलर और अनमर्शलर के साथ वैकल्पिक समाधान
एक अन्य विकल्प एक कस्टम प्रकार लागू करना है, जैसे कि रॉस्ट्रिंग, जो json.Marshaler और json.Unmarshaler इंटरफ़ेस लागू करता है। यह अनमर्शलिंग प्रक्रिया पर अधिक लचीलेपन और नियंत्रण की अनुमति देता है।
यह दृष्टिकोण निम्नलिखित कोड में प्रदर्शित किया गया है:
// 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)
}
अपने स्वयं के प्रकार को लागू करके, हम अनमर्शलिंग प्रक्रिया को अनुकूलित कर सकते हैं और प्रतिबिंब की आवश्यकता से बच सकते हैं, जिसके परिणामस्वरूप एक स्वच्छ और अधिक कुशल समाधान प्राप्त होता है।