Golang에서 중첩 된 JSON 객체 역 마샬링

Golang에서 중첩 된 JSON 객체 역 마샬링

---

있다 몇 가지 질문 온 주제는 하지만 그들 중 누구도 따라서 나는 새로운 하나를 만드는거야, 내 경우를 다루 보이지 않는다.

다음과 같은 JSON이 있습니다.

{"foo":{ "bar": "1", "baz": "2" }, "more": "text"}

중첩 된 막대 속성을 마샬링 해제하고 중첩 된 구조체를 만들지 않고 구조체 속성에 직접 할당하는 방법이 있습니까?

지금 채택하고있는 솔루션은 다음과 같습니다.

type Foo struct {
    More String `json:"more"`
    Foo  struct {
        Bar string `json:"bar"`
        Baz string `json:"baz"`
    } `json:"foo"`
    //  FooBar  string `json:"foo.bar"`
}

이것은 단순화 된 버전입니다. 자세한 내용은 무시하십시오. 보시다시피 값을 구문 분석하고 할당 할 수 있기를 바랍니다.

//  FooBar  string `json:"foo.bar"`

사람들이지도를 사용하는 것을 본 적이 있지만 제 경우는 아닙니다. 나는 기본적으로 foo몇 가지 특정 요소를 제외하고는 (큰 객체 인) 의 내용에 신경 쓰지 않습니다 .

이 경우 올바른 접근 방식은 무엇입니까? 나는 이상한 해킹을 찾고 있지 않으므로 이것이 갈 길이라면 괜찮습니다.

---

중첩 된 막대 속성을 마샬링 해제하고 중첩 된 구조체를 만들지 않고 구조체 속성에 직접 할당하는 방법이 있습니까?

아니요, encoding / json은 encoding / xml과 같이 "> some> deep> childnode"로 트릭을 수행 할 수 없습니다. 중첩 된 구조체는 갈 길입니다.

---

Volker가 언급 한 것처럼 중첩 된 구조체는 갈 길입니다. 당신은하지만 정말 중첩 된 구조체를 싶지 않아, 당신은 UnmarshalJSON의 FUNC을 대체 할 수 있습니다.

https://play.golang.org/p/dqn5UdqFfJt

type A struct {
    FooBar string // takes foo.bar
    FooBaz string // takes foo.baz
    More   string 
}

func (a *A) UnmarshalJSON(b []byte) error {

    var f interface{}
    json.Unmarshal(b, &f)

    m := f.(map[string]interface{})

    foomap := m["foo"]
    v := foomap.(map[string]interface{})

    a.FooBar = v["bar"].(string)
    a.FooBaz = v["baz"].(string)
    a.More = m["more"].(string)

    return nil
}

적절한 오류를 반환하지 않는다는 사실을 무시하십시오. 단순성을 위해 생략했습니다.

업데이트 : "more"값을 올바르게 검색합니다.

---

다음은 Safebrowsing v4 API sbserver 프록시 서버에서 JSON 응답을 비 정렬 화하는 방법의 예입니다. https://play.golang.org/p/4rGB5da0Lt

// this example shows how to unmarshall JSON requests from the Safebrowsing v4 sbserver
package main

import (
    "fmt"
    "log"
    "encoding/json"
)

// response from sbserver POST request
type Results struct {
    Matches []Match     
}

// nested within sbserver response
type Match struct {
    ThreatType string 
    PlatformType string 
    ThreatEntryType string 
    Threat struct {
        URL string
    }
}

func main() {
    fmt.Println("Hello, playground")

    // sample POST request
    //   curl -X POST -H 'Content-Type: application/json' 
    // -d '{"threatInfo": {"threatEntries": [{"url": "http://testsafebrowsing.appspot.com/apiv4/ANY_PLATFORM/MALWARE/URL/"}]}}' 
    // http://127.0.0.1:8080/v4/threatMatches:find

    // sample JSON response
    jsonResponse := `{"matches":[{"threatType":"MALWARE","platformType":"ANY_PLATFORM","threatEntryType":"URL","threat":{"url":"http://testsafebrowsing.appspot.com/apiv4/ANY_PLATFORM/MALWARE/URL/"}}]}`

    res := &Results{}
    err := json.Unmarshal([]byte(jsonResponse), res)
        if(err!=nil) {
            log.Fatal(err)
        }

    fmt.Printf("%v\n",res)
    fmt.Printf("\tThreat Type: %s\n",res.Matches[0].ThreatType)
    fmt.Printf("\tPlatform Type: %s\n",res.Matches[0].PlatformType)
    fmt.Printf("\tThreat Entry Type: %s\n",res.Matches[0].ThreatEntryType)
    fmt.Printf("\tURL: %s\n",res.Matches[0].Threat.URL)
}

---

예. gjson을 사용하면 지금해야 할 일은 다음과 같습니다.

bar := gjson.Get(json, "foo.bar")

bar원한다면 구조체 속성이 될 수 있습니다. 또한지도가 없습니다.

---

익명 필드는 어떻습니까? 이것이 "중첩 된 구조체"를 구성하는지 확실하지 않지만 중첩 된 구조체 선언을 갖는 것보다 깨끗합니다. 중첩 된 요소를 다른 곳에서 재사용하려면 어떻게해야합니까?

type NestedElement struct{
    someNumber int `json:"number"`
    someString string `json:"string"`
}

type BaseElement struct {
    NestedElement `json:"bar"`
}

---

jsonjson 키의 기본 유형을 알 때까지 중첩 값 을 구조체에 할당하십시오 .

package main

import (
    "encoding/json"
    "fmt"
)

// Object
type Object struct {
    Foo map[string]map[string]string `json:"foo"`
    More string `json:"more"`
}

func main(){
    someJSONString := []byte(`{"foo":{ "bar": "1", "baz": "2" }, "more": "text"}`)
    var obj Object
    err := json.Unmarshal(someJSONString, &obj)
    if err != nil{
        fmt.Println(err)
    }
    fmt.Println("jsonObj", obj)
}

---

나는 이런 일을하고 있었다. 그러나 proto에서 생성 된 구조에서만 작동합니다. https://github.com/flowup-labs/grpc-utils

당신의 프로토에서

message Msg {
  Firstname string = 1 [(gogoproto.jsontag) = "name.firstname"];
  PseudoFirstname string = 2 [(gogoproto.jsontag) = "lastname"];
  EmbedMsg = 3  [(gogoproto.nullable) = false, (gogoproto.embed) = true];
  Lastname string = 4 [(gogoproto.jsontag) = "name.lastname"];
  Inside string  = 5 [(gogoproto.jsontag) = "name.inside.a.b.c"];
}

message EmbedMsg{
   Opt1 string = 1 [(gogoproto.jsontag) = "opt1"];
}

그러면 출력이

{
"lastname": "Three",
"name": {
    "firstname": "One",
    "inside": {
        "a": {
            "b": {
                "c": "goo"
            }
        }
    },
    "lastname": "Two"
},
"opt1": "var"
}

---

Combining map and struct allow unmarshaling nested JSON objects where the key is dynamic. => map[string]

For example: stock.json

{
  "MU": {
    "symbol": "MU",
    "title": "micro semiconductor",
    "share": 400,
    "purchase_price": 60.5,
    "target_price": 70
  },
  "LSCC":{
    "symbol": "LSCC",
    "title": "lattice semiconductor",
    "share": 200,
    "purchase_price": 20,
    "target_price": 30
  }
}

Go application

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "os"
)

type Stock struct {
    Symbol        string  `json:"symbol"`
    Title         string  `json:"title"`
    Share         int     `json:"share"`
    PurchasePrice float64 `json:"purchase_price"`
    TargetPrice   float64 `json:"target_price"`
}
type Account map[string]Stock

func main() {
    raw, err := ioutil.ReadFile("stock.json")
    if err != nil {
        fmt.Println(err.Error())
        os.Exit(1)
    }
    var account Account
    log.Println(account)
}

The dynamic key in the hash is handle a string, and the nested object is represented by a struct.

참고URL : https://stackoverflow.com/questions/21268000/unmarshaling-nested-json-objects-in-golang