如何在Go中反序列化混合类型列表及指定JSON结构？

针对你提出的两个问题，我先从你给出的具体JSON示例入手，再延伸到混合类型列表的通用反序列化方法。

一、处理你提供的JMAP请求JSON #

首先看你给出的JSON结构，methodCalls是一个数组，每个元素是混合类型的三元组数组：第一个元素是方法名字符串，第二个是任意结构的参数对象，第三个是客户端ID字符串。你的初步结构体定义没法直接解析，因为Go的标准json包默认只能把数组映射到同类型切片，没法直接映射到结构体字段。

这里的解决方案是给MethodCall类型实现json.Unmarshaler接口，手动处理数组的解析逻辑：

1. 定义结构体 #

package main

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

type Request struct {
    Using       []string      `json:"using"`
    MethodCalls []MethodCall `json:"methodCalls"`
}

type MethodCall struct {
    Name     string                 // 方法名
    Params   map[string]interface{} // 参数，用map接收任意JSON对象
    ClientID string                 // 客户端ID
}

2. 实现自定义反序列化方法 #

因为MethodCall在JSON中是数组而非对象，我们需要手动解析数组的三个元素：

func (mc *MethodCall) UnmarshalJSON(data []byte) error {
    // 先把JSON数组解析成空接口切片
    var rawElements []interface{}
    if err := json.Unmarshal(data, &rawElements); err != nil {
        return fmt.Errorf("failed to parse method call array: %w", err)
    }

    // 校验数组长度必须为3
    if len(rawElements) != 3 {
        return fmt.Errorf("method call array must have 3 elements, got %d", len(rawElements))
    }

    // 解析第一个元素：方法名（必须是字符串）
    var ok bool
    mc.Name, ok = rawElements[0].(string)
    if !ok {
        return fmt.Errorf("first element of method call must be string, got %T", rawElements[0])
    }

    // 解析第三个元素：客户端ID（必须是字符串）
    mc.ClientID, ok = rawElements[2].(string)
    if !ok {
        return fmt.Errorf("third element of method call must be string, got %T", rawElements[2])
    }

    // 解析第二个元素：参数对象
    // 先把参数部分重新序列化为JSON字节，再反序列化为map
    paramsBytes, err := json.Marshal(rawElements[1])
    if err != nil {
        return fmt.Errorf("failed to marshal params: %w", err)
    }
    if err := json.Unmarshal(paramsBytes, &mc.Params); err != nil {
        return fmt.Errorf("failed to parse params: %w", err)
    }

    return nil
}

3. 使用示例 #

func main() {
    jsonInput := `{ 
        "using": [ "jmap-core", "jmap-mail" ], 
        "methodCalls": [ 
            ["method1", {"arg1": "arg1data", "arg2": "arg2data"}, "#1"], 
            ["method2", {"arg1": "arg1data"}, "#2"], 
            ["method3", {}, "#3"] 
        ] 
    }`

    var req Request
    if err := json.Unmarshal([]byte(jsonInput), &req); err != nil {
        log.Fatalf("Failed to parse JSON: %v", err)
    }

    // 打印解析结果
    for _, call := range req.MethodCalls {
        fmt.Printf("Method: %s, ClientID: %s, Params: %v\n", call.Name, call.ClientID, call.Params)
    }
}

运行这段代码就能正确解析出methodCalls里的每个方法调用信息了。如果你的参数有固定结构，还可以把Params换成具体的结构体类型，在解析时反序列化为该结构体即可。

二、通用：如何反序列化包含混合类型的列表 #

处理混合类型列表（即列表元素类型不统一），常见的三种方案：

• 使用[]interface{}接收：适合简单场景，先把整个列表解析成[]interface{}，然后逐个遍历元素，通过类型断言判断元素类型（比如val, ok := elem.(string)），再手动转换。但这种方式类型安全性差，容易出现类型断言失败的情况，适合临时调试或简单结构。
• 自定义类型实现UnmarshalJSON：像上面的例子一样，针对固定结构的混合列表，定义对应类型并实现反序列化接口，手动处理每个元素的解析逻辑，类型安全且可控性强，适合业务中固定格式的混合列表。
• 使用json.RawMessage延迟解析：如果混合列表中的部分元素需要后续根据上下文再解析，可以先把这些元素保留为json.RawMessage（原始JSON字节），之后按需反序列化为具体类型。这种方式适合复杂嵌套、元素类型依赖其他字段的场景。

内容的提问来源于stack exchange，提问作者Peter Meyer