Golang JSON库中RawMessage的原理与实战：延迟解析与预计算

江岸

发布时间：2026-10-15 | 3人浏览过

原创

深入解析Golang标准库中encoding/json的RawMessage类型，阐述其底层基于[]byte的实现机制，并通过代码示例演示如何利用该类型在序列化时复用预计算数据以及在反序列化时进行两阶段延迟解析，从而提升性能并简化复杂JSON结构的处理。

什么是序列化和RawMessage

JSON作为一种通用的数据交换协议，因其良好的可读性和较小的体积，在众多业务场景中广泛应用。在高并发或大数据量处理下，JSON的序列化与反序列化往往成为性能瓶颈，因此许多开发者致力于优化这一过程。

Golang官方json包提供了Marshaler和Unmarshaler两个接口，用于自定义类型的序列化和反序列化行为：

// Marshaler is the interface implemented by types that
type Marshaler interface {
    MarshalJSON() ([]byte, error)
}

// Unmarshaler is the interface implemented by types
type Unmarshaler interface {
    UnmarshalJSON([]byte) error
}

序列化（Marshal）是将对象转换为字节数组（[]byte），而反序列化（Unmarshal）则是将字节数组转换为目标类型值。若自定义类型实现了上述接口，调用json.Marshal或json.Unmarshal时将执行这些自定义逻辑。

RawMessage是json包中定义的一个特殊类型，它同样实现了这两个接口。官方文档指出：“RawMessage是一种原始编码的JSON值，可用于延迟JSON解码或预计算JSON编码。”

查看源码可知，RawMessage本质上是一个[]byte切片：

type RawMessage []byte

func (m RawMessage) MarshalJSON() ([]byte, error) {
    if m == nil {
        return []byte("null"), nil
    }
    return m, nil
}

func (m *RawMessage) UnmarshalJSON(data []byte) error {
    if m == nil {
        return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")
    }
    *m = append((*m)[0:0], data...)
    return nil
}

由此可见，序列化时RawMessage直接返回其内部的字节数组；反序列化时，则将输入的数据拷贝一份存入自身。这种设计使得RawMessage能够保持JSON数据的原始形态，无需经过额外的解析和重构。

使用场景概述

RawMessage的核心价值在于将其作为占位符使用。当数据结构中存在部分字段在不同场景下结构不同，或者需要分阶段解析时，可以使用RawMessage来暂存这些字段的原始字节，避免无效解析。

复用预计算的JSON值

在某些情况下，我们可能需要合并固定的配置信息与动态数据。利用RawMessage，可以直接嵌入预先格式化的JSON字符串，无需重新序列化，从而节省CPU资源。

package main
import (
	"encoding/json"
	"fmt"
	"os"
)

func main() {
	// 定义一个预计算的头部JSON
	h := json.RawMessage(`{"precomputed": true}`)
	
	c := struct {
		Header *json.RawMessage `json:"header"`
		Body   string           `json:"body"`
	}{
		Header: &h,
		Body:   "Hello Gophers!",
	}
	
	b, err := json.MarshalIndent(&c, "", "\t")
	if err != nil {
		fmt.Println("error:", err)
	}
	os.Stdout.Write(b)
}

运行结果如下：

{
	"header": {
		"precomputed": true
	},
	"body": "Hello Gophers!"
}

在此示例中，header字段直接使用预先生成的JSON字节流，Marshal操作几乎无开销地将其写入最终输出。

延迟解析JSON结构

更典型的应用场景是处理具有“差异化载荷”的结构。例如，一个通用消息体中包含不同类型的具体数据，但具体数据的结构取决于某个标识字段。RawMessage允许先解析通用字段，再根据条件决定如何解析载荷部分，即两阶段反序列化。

第1步：定义通用结构体与载荷类型

首先定义包含RawMessage的结构体，以及可能的具体数据类型：

type Color struct {
	Space string            
	Point json.RawMessage // 延迟解析点
}

type RGB struct {
	R uint8
	G uint8
	B uint8
}

type YCbCr struct {
	Y  uint8
	Cb int8
	Cr int8
}

第2步：执行第一级反序列化

将JSON数据映射到Color结构体。由于Point是RawMessage，它只会复制原始字节，不会尝试解析内部结构：

var j = []byte(`[
	{"Space": "YCbCr", "Point": {"Y": 255, "Cb": 0, "Cr": -10}},
	{"Space": "RGB",   "Point": {"R": 98, "G": 218, "B": 255}}
]`)

var colors []Color
err := json.Unmarshal(j, &colors)
if err != nil {
	log.Fatalln("error:", err)
}

第3步：根据上下文执行第二级解析

遍历已解析的对象，根据Space字段的值，选择合适的目标结构体对Point再次进行Unmarshal：

for _, c := range colors {
	var dst any
	switch c.Space {
	case "RGB":
		dst = new(RGB)
	case "YCbCr":
		dst = new(YCbCr)
	}
	// 如果dst为空，说明无法识别的空间，可跳过或报错
	if dst == nil {
		continue
	}
	
	err := json.Unmarshal(c.Point, dst)
	if err != nil {
		log.Fatalln("error:", err)
	}
	fmt.Println(c.Space, dst)
}

输出结果：

YCbCr &{255 0 -10}
RGB &{98 218 255}

这种方式避免了强制所有数据符合单一结构带来的冲突，同时也减少了对无法识别数据的无效解析消耗。

总结

json.RawMessage通过暴露底层[]byte接口，为Golang开发者提供了一种高效处理JSON的手段。无论是为了序列化时的性能优化（复用预计算值），还是反序列化时的灵活性（分阶段解析动态结构），它都是一个强有力的工具。理解其“原样保留、按需解析”的特性，有助于构建更高效、更可扩展的数据交互逻辑。

以上就是Golang JSON库中的RawMessage功能原理的详细内容，更多关于Golang json库RawMessage的资料请关注本站其它相关文章！