如何用多个对象返回设置json结构的格式？(动态)

Question

我有一个API调用，它返回如下：

{
    "result": {
        "720268538": {
            "icon_url": "-9a81dlWLwJ2UUGcVs_nsVtzdOEdtWwKGZZLQHTxDZ7I56KU0Zwwo4NUX4oFJZEHLbXU5A1PIYQNqhpOSV-fRPasw8rsUFJ5KBFZv668FFEuh_KQJTtEuI63xIXbxqOtauyClTMEsJV1jruS89T3iQKx_BBqa2j3JpjVLFH1xpp0EQ",
            "icon_url_large": "",
            "icon_drag_url": "",
            "name": "Chroma Case",
            "market_hash_name": "Chroma Case",
            "market_name": "Chroma Case",
            "name_color": "D2D2D2",
            "background_color": "",
            "type": "Base Grade Container",
            "tradable": "1",
            "marketable": "1",
            "commodity": "1",
            "market_tradable_restriction": "7",
            "fraudwarnings": "",
            "descriptions": {
                "0": {
                    "type": "html",
                    "value": " ",
                    "app_data": ""
                },
                "1": {
                    "type": "html",
                    "value": "Container Series #38",
                    "color": "99ccff",
                    "app_data": ""
                },
                "2": {
                    "type": "html",
                    "value": " ",
                    "app_data": ""
                },
                "3": {
                    "type": "html",
                    "value": "Contains one of the following:",
                    "app_data": ""
                },
                "4": {
                    "type": "html",
                    "value": "Glock-18 | Catacombs",
                    "color": "4b69ff",
                    "app_data": ""
                },
                "5": {
                    "type": "html",
                    "value": "M249 | System Lock",
                    "color": "4b69ff",
                    "app_data": ""
                },
                "6": {
                    "type": "html",
                    "value": "MP9 | Deadly Poison",
                    "color": "4b69ff",
                    "app_data": ""
                },
                "7": {
                    "type": "html",
                    "value": "SCAR-20 | Grotto",
                    "color": "4b69ff",
                    "app_data": ""
                },
                "8": {
                    "type": "html",
                    "value": "XM1014 | Quicksilver",
                    "color": "4b69ff",
                    "app_data": ""
                },
                "9": {
                    "type": "html",
                    "value": "Dual Berettas | Urban Shock",
                    "color": "8847ff",
                    "app_data": ""
                },
                "10": {
                    "type": "html",
                    "value": "Desert Eagle | Naga",
                    "color": "8847ff",
                    "app_data": ""
                },
                "11": {
                    "type": "html",
                    "value": "MAC-10 | Malachite",
                    "color": "8847ff",
                    "app_data": ""
                },
                "12": {
                    "type": "html",
                    "value": "Sawed-Off | Serenity",
                    "color": "8847ff",
                    "app_data": ""
                },
                "13": {
                    "type": "html",
                    "value": "AK-47 | Cartel",
                    "color": "d32ce6",
                    "app_data": ""
                },
                "14": {
                    "type": "html",
                    "value": "M4A4 | 龍王 (Dragon King)",
                    "color": "d32ce6",
                    "app_data": ""
                },
                "15": {
                    "type": "html",
                    "value": "P250 | Muertos",
                    "color": "d32ce6",
                    "app_data": ""
                },
                "16": {
                    "type": "html",
                    "value": "AWP | Man-o'-war",
                    "color": "eb4b4b",
                    "app_data": ""
                },
                "17": {
                    "type": "html",
                    "value": "Galil AR | Chatterbox",
                    "color": "eb4b4b",
                    "app_data": ""
                },
                "18": {
                    "type": "html",
                    "value": "or an Exceedingly Rare Special Item!",
                    "color": "ffd700",
                    "app_data": ""
                },
                "19": {
                    "type": "html",
                    "value": " ",
                    "app_data": ""
                },
                "20": {
                    "type": "html",
                    "value": "",
                    "color": "00a000",
                    "app_data": {
                        "limited": "1"
                    }
                }
            },
            "owner_descriptions": "",
            "tags": {
                "0": {
                    "internal_name": "CSGO_Type_WeaponCase",
                    "name": "Container",
                    "category": "Type",
                    "category_name": "Type"
                },
                "1": {
                    "internal_name": "set_community_6",
                    "name": "The Chroma Collection",
                    "category": "ItemSet",
                    "category_name": "Collection"
                },
                "2": {
                    "internal_name": "normal",
                    "name": "Normal",
                    "category": "Quality",
                    "category_name": "Category"
                },
                "3": {
                    "internal_name": "Rarity_Common",
                    "name": "Base Grade",
                    "category": "Rarity",
                    "color": "b0c3d9",
                    "category_name": "Quality"
                }
            },
            "classid": "720268538"
        },
        "success": true
    }
}

结果可以有多个返回，我想知道这个结构应该是什么样子，这是我到目前为止得到的，但是它没有返回。

type AssetInfo struct {
    Result `json:"result"`
}

type Result struct {
    Asset   map[string]Asset `json:"asset"`
    Success bool             `json:"success,omitempty"`
}

type Asset struct {
    IconUrl           string                   `json:"icon_url,omitempty"`
    IconUrlLarge      string                   `json:"icon_url_large,omitempty"`
    IconDragUrl       string                   `json:"icon_drag_url,omitempty"`
    Name              string                   `json:"name,omitempty"`
    MarketHashName    string                   `json:"market_hash_name,omitempty"`
    MarketName        string                   `json:"market_name,omitempty"`
    NameColor         string                   `json:"name_color,omitempty"`
    BGColor           string                   `json:"background_color,omitempty"`
    Type              string                   `json:"type,omitempty"`
    Tradable          string                   `json:"tradable,omitempty"`
    Marketable        string                   `json:"marketable,omitempty"`
    Commodity         string                   `json:"commodity,omitempty"`
    TradeRestrict     string                   `json:"market_tradeable_restriction,omitempty"`
    FraudWarnings     string                   `json:"fraudwarnings,omitempty"`
    Descriptions      map[string]*Descriptions `json:"descriptions,omitempty"`
    OwnerDescriptions string                   `json:"owner_descriptions,omitempty"`
    Tags              map[string]*Tags         `json:"tags,omitempty"`
    ClassId           string                   `json:"classid,omitempty"`
}

type Descriptions struct {
    Type    string `json:"type"`
    Value   string `json:"value"`
    Color   string `json:"color,omitempty"`
    AppData string `json:"appdata"`
}

type Tags struct {
    InternalName string `json:"internal_name"`
    Name         string `json:"name"`
    Category     string `json:"category"`
    Color        string `json:"color,omitempty"`
    CategoryName string `json:"category_name"`
}

如果有人能告诉我我的结构有什么问题，那就太好了，谢谢。

让我困惑的是，描述返回的不是数组，而是多个对象，这些对象可以从0到20不等，当我不知道要返回多少个对象时，如何准备一个结构？result也可以返回多个"720616831"，这应该是什么样子呢？

Answer 1

您将为第一个错误而自责--您的JSON有result，而struct标记有response。

第二个问题是更棘手的问题。问题是，您声明您的Asset映射作为一个名为“资产”的键嵌套在结果中，但事实并非如此。实际上，这只是结果的所有关键，而不是成功/错误。不幸的是，encoding/json没有任何方法来表达这一点。您可以说result是一个map[string]interface{}，如果它们存在，那么成功/错误将是bool/map[string]interface{}，而资产将是包含所有其他字段的键的更多map[string]interface{}。这是可行的，但它有点丑陋/低效，如果您想要转换成适当的struct类型，那么就需要做大量的工作，这样您就可以使用方法了。

也许一个更好的方法是解码成这种类型：

type AssetIntermediate struct {
    Result map[string]json.RawMessage `json:"result"`
}

以及拥有

type Asset struct { /* all those fields */ }
type AssetInfo struct {
    Success bool
    Error string
    Assets map[string]Asset
}

那你就可以

var intermediate AssetIntermediate
err := json.Unmarshal(data, &intermediate)
/* handle err */

var ai AssetInfo

/* At this point, intermediate.Result is a map
 * of strings to json.RawMessage, which is just a []byte
 * containing not-yet-decoded JSON. We want to take
 * each field and put it into ai where it belongs.
 */
for k, v := range intermediate.Result {
    var err error
    // error and success keys are decoded into the respective fields
    if k == "error" {
        err = json.Unmarshal(v, &ai.Error)
    } else if k == "success" {
        err = json.Unmarshal(v, &ai.Success)
    } else {
        // Otherwise, we have an asset. First decode it...
        var asset Asset
        err = json.Unmarshal(v, &asset)
        if err == nil {
            // Create the Assets map if it doesn't exist yet
            if ai.Assets == nil {
                ai.Assets = map[string]Asset{}
            }
            // And store the asset in the map under the key k.
            ai.Assets[k] = asset
        }
    }
    /* handle err if non-nil */
}

这比一个Decode调用要做的工作要多得多，但它基本上应该做正确的事情。

如果所有这些都在返回(*AssetInfo, error)的函数中，那么取代/* Handle err */的正确方法可能是

if err != nil {
    return nil, err
}

Answer 2

我建议使用基本的map[string]interface{}类型，并从json字符串中迭代，直到您可以构建整个结构。对于那些你并不真正知道键的部分，比如0-20，地图可能是你所拥有的全部。

例如，假设示例中的字符串位于变量j中。你可以从以下方面开始：

type AssetInfo struct {
    Result map[string]interface{}
}

并开始解组和打印，以找到完整的结构：

var ai AssetInfo
json.Unmarshal([]byte(j), &ai)
fmt.Printf("%#v\n", ai)

这将打印解封后生成的整个地图。尝试用这样复杂的结构预先构建整个结构是不可能得到结果的。

编辑:如果像对待map[string]struct一样，将结果视为Descriptions，那么成功的bool将“丢失”并进入映射，但json的其余部分正确地解组。我看不到支持Success bool的方法，也看不到其他结构的映射。至于编号的键，如果您需要一个片段，您将不得不在解封后做一些工作。

type AssetInfo struct {
    Result map[string]Numbered
}

type Numbered struct {
    IconUrl          string                 `json:"icon_url"`
    IconUrlLarge     string                 `json:"icon_url_large"`
    IconDragUrl      string                 `json:"icon_drag_url"`
    Name             string                 `json:"name"`
    MarketHashName   string                 `json:"market_hash_name"`
    MarketName       string                 `json:"market_name"`
    NameColor        string                 `json:"name_color"`
    BGColor          string                 `json:"background_color"`
    Type             string                 `json:"type"`
    Tradable         string                 `json:"tradable"`
    Marketable       string                 `json:"marketable"`
    Commodity        string                 `json:"commodity"`
    TradeRestrict    string                 `json:"market_tradeable_restriction"`
    FraudWarnings    string                 `json:"fraudwarnings"`
    Descriptions     map[string]description `json:"descriptions"`
    OwnerDescription string                 `json:"owner_descriptions"`
    Tags             map[string]tag         `json:"tags"`
    ClassID          string                 `json:"classid"`
}

type description struct {
    Type    string `json:"type"`
    Value   string `json:"value"`
    Color   string `json:"color,omitempty"`
    AppData string `json:"appdata"`
}

type tag struct {
    InternalName string `json:"internal_name"`
    Name         string `json:"name"`
    Category     string `json:"category"`
    Color        string `json:"color,omitempty"`
    CategoryName string `json:"category_name"`
}

func main() {
    var ai AssetInfo
    json.Unmarshal([]byte(j), &ai)
    fmt.Printf("%+v\n", ai.Result["720268538"].Tags)
}

Tags的输出是map[0:{InternalName:CSGO_Type_WeaponCase Name:Container Category:Type Color: CategoryName:Type} 1:{InternalName:set_community_6 Name:The Chroma Collection Category:ItemSet Color: CategoryName:Collection} (...)

编辑2:经过在评论中的讨论，我得到了一些代码，这与霍布斯的回答非常相似。他的可能会更有条理。

我们需要使用json.RawMessage，因为"success"的true值不能进入Numbered结构。

type AssetInfo struct {
    Result map[string]json.RawMessage
}

err := json.Unmarshal([]byte(j), &ai)
fmt.Println("outer error", err) // prints <nil>
for k, v := range ai.Result {
    // this is very similar to the example on the docs: https://golang.org/pkg/encoding/json/#RawMessage
    var dst interface{} 
    if k == "success" {
        dst = new(bool)
    } else {
        dst = new(Numbered)
    }
    err := json.Unmarshal(v, dst)
    fmt.Println("inner error", err) // prints <nil>
    if k == "success" {
        b := dst.(*bool)
        fmt.Printf("%t\n", *b) // true
    } else {
        fmt.Printf("%+v\n", dst) // the whole Numbered struct
    }
}