首页 > Golang > Go问答

这些数据为何不能正确映射到我的对象模型？

来源：stackoverflow

时间：2024-03-26 21:54:34 285浏览收藏

**摘要：** 本文讨论了解组 JSON 数据到自定义对象模型时遇到的问题。问题是 JSON 数据中的嵌套结构与目标对象模型不匹配，导致无法正确映射数据。解决方案涉及修改目标对象模型以匹配 JSON 结构，允许嵌套数据正确解组。文中提供了一些示例代码，展示了如何根据提供的 JSON 数据创建必要的对象模型。

问题内容

我这里有一个（非）工作示例：https://play.golang.org/p/qayhkvj65j3

我不确定为什么会出现以下数据：

alertdata := `{
    "id": 0,
    "version": 0,
    "orgid": 1,
    "dashboardid": 61,
    "panelid": 84,
    "name": "{qa-dev}{stats-pipeline} topology message age (aggregator) alert",
    "message": "",
    "severity": "",
    "state": "",
    "handler": 1,
    "silenced": false,
    "executionerror": "",
    "frequency": 10,
    "evaldata": null,
    "newstatedate": "0001-01-01t00:00:00z",
    "prevstatedate": "0001-01-01t00:00:00z",
    "statechanges": 0,
    "created": "0001-01-01t00:00:00z",
    "updated": "0001-01-01t00:00:00z",
    "settings": {
        "conditions": [
            {
                "evaluator": {
                    "params": [
                        10000
                    ],
                    "type": "gt"
                },
                "operator": {
                    "type": "and"
                },
                "query": {
                    "datasourceid": 2,
                    "model": {
                        "hide": true,
                        "refcount": 0,
                        "refid": "c",
                        "texteditor": false
                    },
                    "params": [
                        "c",
                        "5m",
                        "now"
                    ]
                },
                "reducer": {
                    "params": [],
                    "type": "avg"
                },
                "type": "query"
            }
        ],
        "executionerrorstate": "keep_state",
        "frequency": "10s",
        "handler": 1,
        "name": "{qa-dev}{stats-pipeline} topology message age (aggregator) alert",
        "nodatastate": "keep_state",
        "notifications": []
    }
}`

无法解组为以下对象模型：

type condition struct {
    evaluator struct {
        params []int  `json:"params"`
        type   string `json:"type"`
    } `json:"evaluator"`
    operator struct {
        type string `json:"type"`
    } `json:"operator"`
    query struct {
        params []string `json:"params"`
    } `json:"query"`
    reducer struct {
        params []interface{} `json:"params"`
        type   string        `json:"type"`
    } `json:"reducer"`
    type string `json:"type"`
}

当我执行以下操作时：

condition := Condition{}
err := json.Unmarshal([]byte(alertData), &condition)

if err != nil {
    panic(err)
}

fmt.Printf("\n\n json object:::: %+v", condition)

我刚刚得到：json object:::: {evaluator:{params:[] type:} operator:{type:} query:{params:[]}reducer:{params:[] type:} type: }

理想情况下，我能够将其解析为类似 type conditions []struct{ } 的内容，但我不确定您是否可以将模型定义为列表？

解决方案

您似乎正在尝试访问嵌套在根“设置”属性下的“条件”属性。因此，您需要定义根级别类型和足够的字段来告诉解组器如何查找目标属性。因此，您只需要创建一个带有必要的“设置/条件”字段的新“alertdata”类型。

例如（Go Playground）：

type alertdata struct {
  settings struct {
    conditions []condition `json:"conditions"`
  }
}

func main() {
  alert := alertdata{}
  err := json.unmarshal([]byte(alertdata), &alert)

  if err != nil {
    panic(err)
  }

  fmt.printf("ok: conditions=%#v\n", alert.settings.conditions)
  // ok: conditions=[]main.condition{main.condition{evaluator:struct { params []int "json:\"params\""; type string "json:\"type\"" }{params:[]int{10000}, type:"gt"}, operator:struct { type string "json:\"type\"" }{type:"and"}, query:struct { params []string "json:\"params\"" }{params:[]string{"c", "5m", "now"}}, reducer:struct { params []interface {} "json:\"params\""; type string "json:\"type\"" }{params:[]interface {}{}, type:"avg"}, type:"query"}}
}

请注意，打印的列表包含如此多的类型信息，因为“条件”类型使用匿名结构作为字段类型。如果您将它们提取到命名结构中，那么处理数据会更容易，例如：

type condition struct {
  evaluator evaluator `json:"evaluator"`
  operator  operator  `json:"operator"`
  // ...
}

type evaluator struct {
  params []int  `json:"params"`
  type   string `json:"type"`
}

type operator struct {
  type string `json:"type"`
}

//...
// ok: conditions=[]main.condition{
//   main.condition{
//     evaluator:main.evaluator{params:[]int{10000}, type:"gt"},
//     operator:main.operator{type:"and"},
//     query:main.query{params:[]string{"c", "5m", "now"}},
//     reducer:main.reducer{params:[]interface {}{}, type:"avg"},
//     type:"query",
//   },
// }

Go Playground example here...

maerics 的解释是正确的，这是一种替代方法，它包装了结构方法的访问，数据结构也已完全定义。如果您是 go 新手，最好自己动手创建数据结构，但这里有一个方便的实用程序，可帮助您从有效的 json 创建结构 https://mholt.github.io/json-to-go/

package main

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

type Data struct {
    ID             int         `json:"Id"`
    Version        int         `json:"Version"`
    OrgID          int         `json:"OrgId"`
    DashboardID    int         `json:"DashboardId"`
    PanelID        int         `json:"PanelId"`
    Name           string      `json:"Name"`
    Message        string      `json:"Message"`
    Severity       string      `json:"Severity"`
    State          string      `json:"State"`
    Handler        int         `json:"Handler"`
    Silenced       bool        `json:"Silenced"`
    ExecutionError string      `json:"ExecutionError"`
    Frequency      int         `json:"Frequency"`
    EvalData       interface{} `json:"EvalData"`
    NewStateDate   time.Time   `json:"NewStateDate"`
    PrevStateDate  time.Time   `json:"PrevStateDate"`
    StateChanges   int         `json:"StateChanges"`
    Created        time.Time   `json:"Created"`
    Updated        time.Time   `json:"Updated"`
    Settings       struct {
        Conditions          []Condition   `json:"conditions"`
        ExecutionErrorState string        `json:"executionErrorState"`
        Frequency           string        `json:"frequency"`
        Handler             int           `json:"handler"`
        Name                string        `json:"name"`
        NoDataState         string        `json:"noDataState"`
        Notifications       []interface{} `json:"notifications"`
    } `json:"Settings"`
}

type Condition struct {
    Evaluator struct {
        Params []int  `json:"params"`
        Type   string `json:"type"`
    } `json:"evaluator"`
    Operator struct {
        Type string `json:"type"`
    } `json:"operator"`
    Query struct {
        DatasourceID int `json:"datasourceId"`
        Model        struct {
            Hide       bool   `json:"hide"`
            RefCount   int    `json:"refCount"`
            RefID      string `json:"refId"`
            TextEditor bool   `json:"textEditor"`
        } `json:"model"`
        Params []string `json:"params"`
    } `json:"query"`
    Reducer struct {
        Params []interface{} `json:"params"`
        Type   string        `json:"type"`
    } `json:"reducer"`
    Type string `json:"type"`
}

func (d Data) GetFirstCondition() (Condition, error) {
    if len(d.Settings.Conditions) > 0 {
        return d.Settings.Conditions[0], nil
    }
    return Condition{}, fmt.Errorf("no conditions found")
}

func (d Data) GetConditionByIndex(index uint) (Condition, error) {
    if len(d.Settings.Conditions) == 0 {
        return Condition{}, fmt.Errorf("no conditions found")
    }

    if int(index) > len(d.Settings.Conditions)-1 {
        return Condition{}, fmt.Errorf("index out of bounds")
    }

    return d.Settings.Conditions[index], nil
}

var alertData = `{
    "Id": 0,
    "Version": 0,
    "OrgId": 1,
    "DashboardId": 61,
    "PanelId": 84,
    "Name": "{qa-dev}{stats-pipeline} Topology Message Age (aggregator) alert",
    "Message": "",
    "Severity": "",
    "State": "",
    "Handler": 1,
    "Silenced": false,
    "ExecutionError": "",
    "Frequency": 10,
    "EvalData": null,
    "NewStateDate": "0001-01-01T00:00:00Z",
    "PrevStateDate": "0001-01-01T00:00:00Z",
    "StateChanges": 0,
    "Created": "0001-01-01T00:00:00Z",
    "Updated": "0001-01-01T00:00:00Z",
    "Settings": {
        "conditions": [
            {
                "evaluator": {
                    "params": [
                        10000
                    ],
                    "type": "gt"
                },
                "operator": {
                    "type": "and"
                },
                "query": {
                    "datasourceId": 2,
                    "model": {
                        "hide": true,
                        "refCount": 0,
                        "refId": "C",
                        "textEditor": false
                    },
                    "params": [
                        "C",
                        "5m",
                        "now"
                    ]
                },
                "reducer": {
                    "params": [],
                    "type": "avg"
                },
                "type": "query"
            }
        ],
        "executionErrorState": "keep_state",
        "frequency": "10s",
        "handler": 1,
        "name": "{qa-dev}{stats-pipeline} Topology Message Age (aggregator) alert",
        "noDataState": "keep_state",
        "notifications": []
    }
}`

func main() {
    var res Data
    err := json.Unmarshal([]byte(alertData), &res)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(res.GetFirstCondition())
    fmt.Println(res.GetConditionByIndex(0))
    // should fail :-)
    fmt.Println(res.GetConditionByIndex(1))

}

好了，本文到此结束，带大家了解了《这些数据为何不能正确映射到我的对象模型？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！

声明：本文转载于：stackoverflow 如有侵犯，请联系study_golang@163.com删除