dongzhang3482 2018-06-06 11:32
浏览 426


So, my use case consists of parsing varying JSON schemas into new struct types, which will be further used with an ORM to fetch data from a SQL database. Being compiled in nature, I believe there will not be an out-of-the-box solution in go, but is there any hack available to do this, without creating a separate go process. I tried with reflection, but could not find a satisfactory approach.

Currently, I am using a-h generate library which does generate the structs, but I am stuck at how to load these new struct types in go runtime.


Example JSON Schema:

  "$schema": "",
  "title": "Address",
  "id": "Address",
  "type": "object",
  "description": "address",
  "properties": {
    "houseName": {
      "type": "string",
      "description": "House Name",
      "maxLength": 30
    "houseNumber": {
      "type": "string",
      "description": "House Number",
      "maxLength": 4
    "flatNumber": {
      "type": "string",
      "description": "Flat",
      "maxLength": 15
    "street": {
      "type": "string",
      "description": "Address 1",
      "maxLength": 40
    "district": {
      "type": "string",
      "description": "Address 2",
      "maxLength": 30
    "town": {
      "type": "string",
      "description": "City",
      "maxLength": 20
    "county": {
      "type": "string",
      "description": "County",
      "maxLength": 20
    "postcode": {
      "type": "string",
      "description": "Postcode",
      "maxLength": 8

Now, in the above-mentioned library, there is a command line tool, which generates the text for struct type for above json as below:

// Code generated by schema-generate. DO NOT EDIT.

package main

// Address address
type Address struct {
  County string `json:"county,omitempty"`
  District string `json:"district,omitempty"`
  FlatNumber string `json:"flatNumber,omitempty"`
  HouseName string `json:"houseName,omitempty"`
  HouseNumber string `json:"houseNumber,omitempty"`
  Postcode string `json:"postcode,omitempty"`
  Street string `json:"street,omitempty"`
  Town string `json:"town,omitempty"`

Now, the issue is that how to use this struct type without re-compilation in the program. There is a hack, where I can start a new go process, but that doesn't seem a good way to do it. One other way is to write my own parser for unmarshalling JSON schema, something like:

b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)
var f interface{}
json.Unmarshal(b, &f)
m := f.(map[string]interface{})
for k, v := range m {
    switch vv := v.(type) {
    case string:
        fmt.Println(k, "is string", vv)
    case float64:
        fmt.Println(k, "is float64", vv)
    case int:
        fmt.Println(k, "is int", vv)
    case []interface{}:
        fmt.Println(k, "is an array:")
        for i, u := range vv {
            fmt.Println(i, u)
        fmt.Println(k, "is of a type I don't know how to handle")

Can someone please suggest some pointers to look for. Thanks.

  • 写回答

1条回答 默认 最新

  • duanpacan2583 2018-06-06 12:49

    So it looks like you're trying to implement your own json marshalling. That's no biggie: the standard json package already supports that. Just have your type implement the MarshalJSON and UnmarshalJSON functions (cf first example on the docs). Assuming some fields will be shared (eg schema, id, type), you can create a unified type like this:

    // poor naming, but we need this level of wrapping here
    type Data struct {
    type Metadata struct {
        Schema string `json:"$schema"`
        Type string `json:"type"`
        Description string `json:"description"`
        Id string `json:"id"`
        Properties json.RawMessage `json:"properties"`
        Address *Address `json:"-"`
        // other types go here, too

    Now all properties will be unmarshalled into a json.RawMessage field (essentially this is a []byte field). What you can do in your custom unmarshall function now is something like this:

    func (d *Data) UnmarshalJSON(b []byte) error {
        meta := Metadata{}
        // unmarshall common fields
        if err := json.Unmarshal(b, &meta); err != nil {
            return err
        // Assuming the Type field contains the value that allows you to determine what data you're actually unmarshalling
        switch meta.Type {
        case "address":
            meta.Address = &Address{} // initialise field
            if err := json.Unmarshal([]byte(meta.Properties), meta.Address); err != nil {
                return err
        case "name":
            meta.Name = &Name{}
            if err := json.Unmarshal([]byte(meta.Properties), meta.Name); err != nil {
                return err
            return errors.New("unknown message type")
        // all done
        d.Metadata = meta // assign to embedded
        // optionally: clean up the Properties field, as it contains raw JSON, and is exported
        d.Metadata.Properties = json.RawMessage{}
        return nil

    You can do pretty much the same thing for marshalling. First work out what type you're actually working with, then marshal that object into the properties field, and then marhsal the entire structure

    func (d Data) MarshalJSON() ([]byte, error) {
        var (
            prop []byte
            err error
        switch {
        case d.Metadata.Address != nil:
            prop, err = json.Marshal(d.Address)
        case d.Metadata.Name != nil:
            prop, err = json.Marshal(d.Name) // will only work if field isn't masked, better to be explicit
            err = errors.New("No properties to marshal") // handle in whatever way is best
        if err != nil {
            return nil, err
        d.Metadata.Properties = json.RawMessage(prop)
        return json.Marshal(d.Metadata) // marshal the unified type here
    本回答被题主选为最佳回答 , 对您是否有帮助呢?



  • ¥20 腾讯企业邮箱邮件可以恢复么
  • ¥15 有人知道怎么将自己的迁移策略布到edgecloudsim上使用吗?
  • ¥15 错误 LNK2001 无法解析的外部符号
  • ¥50 安装pyaudiokits失败
  • ¥15 计组这些题应该咋做呀
  • ¥60 更换迈创SOL6M4AE卡的时候,驱动要重新装才能使用,怎么解决?
  • ¥15 让node服务器有自动加载文件的功能
  • ¥15 jmeter脚本回放有的是对的有的是错的
  • ¥15 r语言蛋白组学相关问题
  • ¥15 Python时间序列如何拟合疏系数模型