Golang中如何将WebSocket数据的interface字段解析为指定结构体

嘿，刚接触Go就搞WebSocket数据解析，给你捋捋怎么把Event里的Data字段（interface{}类型）转换成你需要的OrderBook结构体！

首先先补全你没写完的OrderBookItem（默认应该包含价格和数量字段吧？）：

type OrderBookItem struct {
    Price  float64 `json:"price"`
    Amount float64 `json:"amount"`
}

接下来分两种常见场景给你解决方案：

场景1：确定当前Event的Data就是OrderBook类型 #

如果你的WebSocket只处理订单簿相关事件，或者已经通过Event字段判断出这是订单簿更新，那最直接的方式是定义一个带具体Data类型的结构体，跳过interface{}的中间步骤：

// 定义专门的订单簿事件结构体
type OrderBookEvent struct {
    Event string     `json:"event"`
    Data  OrderBook  `json:"data"`
}

然后直接用json.Unmarshal解析WebSocket收到的字节数据：

// 假设wsMsg是从WebSocket接收到的字节数组
var obEvent OrderBookEvent
if err := json.Unmarshal(wsMsg, &obEvent); err != nil {
    // 一定要处理错误，比如JSON格式不对、字段缺失等
    log.Printf("解析订单簿事件失败：%v", err)
    return
}

// 直接使用obEvent.Data即可，已经是OrderBook类型了
fmt.Println("当前交易对：", obEvent.Data.Pair)
fmt.Println("买盘第一档价格：", obEvent.Data.Bids[0].Price)

这种方式代码简洁，不需要额外类型转换，效率也更高。

场景2：Event的Data可能是多种类型（多事件场景） #

如果你的WebSocket会收到多种事件（比如订单更新、行情推送等），必须先解析到通用的Event结构体，再根据Event字段的值转换Data，那可以用先序列化再反序列化的方式：

// 先解析到通用Event结构体
var e Event
if err := json.Unmarshal(wsMsg, &e); err != nil {
    log.Printf("解析通用事件失败：%v", err)
    return
}

// 根据event字段判断是否是订单簿事件
if e.Event != "orderbook_update" {
    // 处理其他类型事件
    return
}

// 把interface{}类型的Data转换成OrderBook
var orderBook OrderBook
// 先把Data序列化成JSON字节
dataBytes, err := json.Marshal(e.Data)
if err != nil {
    log.Printf("序列化Data失败：%v", err)
    return
}
// 再反序列化成OrderBook
if err := json.Unmarshal(dataBytes, &orderBook); err != nil {
    log.Printf("解析OrderBook失败：%v", err)
    return
}

// 现在orderBook就是你需要的结构体了
fmt.Println("订单簿时间戳：", orderBook.Timestamp)

为什么不直接用类型断言？ #

可能你会想直接把e.Data断言成map[string]interface{}然后逐个字段赋值，但这种方式太繁琐——不仅要处理每个字段的类型转换（比如把string转成float64），还要处理切片类型的Bids和Asks，容易出错。用序列化再反序列化的方式，相当于让Go的JSON库帮你做所有类型转换，省心多了。

完整示例代码 #

package main

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

type OrderBookItem struct {
    Price  float64 `json:"price"`
    Amount float64 `json:"amount"`
}

type OrderBook struct {
    Pair      string          `json:"pair"`
    Timestamp string          `json:"timestamp"`
    Broker    string          `json:"broker"`
    Bids      []OrderBookItem `json:"bids"`
    Asks      []OrderBookItem `json:"asks"`
}

type Event struct {
    Event string      `json:"event"`
    Data  interface{} `json:"data"`
}

func main() {
    // 模拟WebSocket收到的订单簿更新数据
    wsMsg := []byte(`{
        "event": "orderbook_update",
        "data": {
            "pair": "BTC/USDT",
            "timestamp": "1700000000",
            "broker": "test_exchange",
            "bids": [{"price": 29990.5, "amount": 1.2}, {"price": 29980.0, "amount": 0.8}],
            "asks": [{"price": 30010.2, "amount": 0.5}, {"price": 30020.0, "amount": 1.5}]
        }
    }`)

    // 方法1：直接解析到OrderBookEvent
    type OrderBookEvent struct {
        Event string    `json:"event"`
        Data  OrderBook `json:"data"`
    }
    var obEvent OrderBookEvent
    if err := json.Unmarshal(wsMsg, &obEvent); err != nil {
        log.Fatalf("方法1解析失败：%v", err)
    }
    fmt.Println("=== 方法1结果 ===")
    fmt.Printf("交易对：%s\n", obEvent.Data.Pair)
    fmt.Printf("买盘第一档：价格%.2f，数量%.2f\n", obEvent.Data.Bids[0].Price, obEvent.Data.Bids[0].Amount)

    // 方法2：通用Event转换
    var e Event
    if err := json.Unmarshal(wsMsg, &e); err != nil {
        log.Fatalf("方法2解析通用Event失败：%v", err)
    }
    if e.Event != "orderbook_update" {
        log.Fatal("不是订单簿更新事件")
    }
    var orderBook OrderBook
    dataBytes, err := json.Marshal(e.Data)
    if err != nil {
        log.Fatalf("序列化Data失败：%v", err)
    }
    if err := json.Unmarshal(dataBytes, &orderBook); err != nil {
        log.Fatalf("解析OrderBook失败：%v", err)
    }
    fmt.Println("\n=== 方法2结果 ===")
    fmt.Printf("时间戳：%s\n", orderBook.Timestamp)
    fmt.Printf("卖盘第一档：价格%.2f，数量%.2f\n", orderBook.Asks[0].Price, orderBook.Asks[0].Amount)
}

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