本文深入探讨了go语言中`json.rawmessage`类型在结构体中嵌入时可能遇到的二次编码问题及其解决方案。当`json.rawmessage`作为非指针类型直接嵌入结构体并进行序列化时，其内容会被错误地base64编码。通过将其定义为`*json.rawmessage`（指针类型），可以确保json数据在序列化和反序列化过程中保持原始字节形式，从而实现正确的延迟解析和数据处理。
在Go语言的encoding/json包中，json.RawMessage是一个非常实用的类型，它允许我们延迟解析JSON数据。这意味着我们可以将JSON的一个子部分作为原始字节存储起来，直到需要时再进行解析。这对于处理大型或结构不确定的JSON数据，或者在代理服务中转发JSON负载而无需完全解析时，都非常有用。然而，在使用json.RawMessage时，如果不注意其在结构体中的定义方式，可能会遇到一个常见的陷阱：JSON数据被意外地二次编码（即被base64编码），导致后续解析失败。
json.RawMessage的用途与常见问题
json.RawMessage本质上是[]byte的别名。它实现了json.Marshaler和json.Unmarshaler接口，使得encoding/json包能够特殊处理它，将其视为一个完整的JSON片段，而不是一个普通的字节切片。
当我们将json.RawMessage直接嵌入到一个结构体中时，例如：
type Data struct {
Name string
Id int
Json json.RawMessage // 注意这里是非指针类型
}并尝试对包含Data类型实例的结构体进行序列化（json.Marshal）和反序列化（json.Unmarshal），然后进一步解析Json字段时，就会出现问题。
让我们通过一个示例来演示这个问题：
package main
import (
"encoding/json"
"fmt"
)
// Data2 是一个简单的结构体，用于演示被嵌入的JSON数据
type Data2 struct {
Name string
Id int
}
// Data 结构体包含一个json.RawMessage字段
type Data struct {
Name string
Id int
Json json.RawMessage // 问题所在：非指针类型
}
func main() {
// 1. 准备一个要嵌入的JSON数据
tmp := Data2{"World", 2}
b, err := json.Marshal(tmp)
if err != nil {
fmt.Printf("Error marshaling Data2: %s\n", err.Error())
return
}
fmt.Printf("原始JSON数据 (b): %s\n", string(b)) // 输出: {"Name":"World","Id":2}
// 2. 将原始JSON数据嵌入到Data结构体中并进行序列化
test := Data{"Hello", 1, b}
b2, err := json.Marshal(test)
if err != nil {
fmt.Printf("Error marshaling Data: %s\n", err.Error())
return
}
fmt.Printf("包含RawMessage的结构体序列化结果 (b2): %s\n", string(b2))
// 预期：{"Name":"Hello","Id":1,"Json":{"Name":"World","Id":2}}
// 实际：{"Name":"Hello","Id":1,"Json":"eyJOYW1lIjoiV29ybGQiLCJJZCI6Mn0="}
// 3. 反序列化外部结构体
var d Data
err = json.Unmarshal(b2, &d)
if err != nil {
fmt.Printf("Error unmarshaling b2 into Data: %s\n", err.Error())
return
}
fmt.Printf("反序列化后d.Json的内容: %s\n", string(d.Json))
// 实际： "eyJOYW1lIjoiV29ybGQiLCJJZCI6Mn0=" (带引号的base64字符串)
// 4. 尝试解析d.Json字段
var tmp2 Data2
err = json.Unmarshal(d.Json, &tmp2) // 这里会报错
if err != nil {
fmt.Printf("Error unmarshaling d.Json into Data2: %s\n", err.Error())
// 输出: Error unmarshaling d.Json into Data2: json: cannot unmarshal string into Go value of type main.Data2
return
}
fmt.Printf("解析后的Data2: %+v\n", tmp2)
}运行上述代码，你会发现b2中的Json字段被序列化成了一个base64编码的字符串（例如"eyJOYW1lIjoiV29ybGQiLCJJZCI6Mn0="），而不是原始的JSON对象。当尝试对这个base64编码的字符串进行json.Unmarshal时，encoding/json会报错，因为它期望一个JSON对象或数组，而不是一个普通的字符串。
问题分析：为什么会发生二次编码？
当json.RawMessage被定义为非指针类型（json.RawMessage）嵌入结构体时，encoding/json包在序列化外部结构体时，会将其视为一个普通的[]byte字段。对于普通的[]byte字段，encoding/json的默认行为是将其内容进行base64编码，然后作为JSON字符串值的一部分输出。
虽然json.RawMessage本身实现了MarshalJSON和UnmarshalJSON方法，但这些方法在外部结构体进行序列化/反序列化时，并不会总是按照我们期望的方式被触发来保持其原始JSON形式。当外部结构体被序列化时，如果Json字段是一个非指针的json.RawMessage，encoding/json会倾向于将其内部的[]byte数据当作普通二进制数据进行base64编码，然后用双引号括起来形成一个JSON字符串。
本程序源码为asp与acc编写，并没有花哨的界面与繁琐的功能，维护简单方便，只要你有一些点点asp的基础，二次开发易如反掌。 1.功能包括产品，新闻，留言簿，招聘，下载，...是大部分中小型的企业建站的首选。本程序是免费开源，只为大家学习之用。如果用于商业，版权问题概不负责。1.采用asp+access更加适合中小企业的网站模式。 2.网站页面div+css兼容目前所有主流浏览器，ie6+，Ch
反序列化时，d.Json会接收到这个带双引号的base64编码字符串的字节表示。此时，d.Json的内容是[]byte("eyJOYW1lIjoiV29ybGQiLCJJZCI6Mn0=")。当你再调用json.Unmarshal(d.Json, &tmp2)时，你实际上是在尝试将一个JSON字符串（其内容是base64编码的二进制数据）反序列化到一个Go结构体Data2中，这显然是不匹配的，因此会失败。
解决方案：使用*json.RawMessage
解决这个问题的关键在于将结构体中的json.RawMessage字段定义为指针类型：*json.RawMessage。
当encoding/json包遇到*json.RawMessage类型的字段时，它会识别出这是一个特殊类型，并正确地调用其底层实现的MarshalJSON和UnmarshalJSON方法。这些方法确保了*json.RawMessage在序列化时被当作一个独立的JSON片段（而不是一个普通字符串），并直接输出其内部的原始JSON字节，而在反序列化时，它会从JSON中提取出原始的字节数据填充到*json.RawMessage中，避免了base64编码。
下面是修改后的代码示例：
package main
import (
"encoding/json"
"fmt"
)
// Data2 是一个简单的结构体，用于演示被嵌入的JSON数据
type Data2 struct {
Name string
Id int
}
// Data 结构体包含一个json.RawMessage字段
type Data struct {
Name string
Id int
Json *json.RawMessage // 关键修改：使用指针类型
}
func main() {
// 1. 准备一个要嵌入的JSON数据
tmp := Data2{"World", 2}
b, err := json.Marshal(tmp)
if err != nil {
fmt.Printf("Error marshaling Data2: %s\n", err.Error())
return
}
fmt.Printf("原始JSON数据 (b): %s\n", string(b)) // 输出: {"Name":"World","Id":2}
// 2. 将原始JSON数据嵌入到Data结构体中并进行序列化
// 注意：这里需要传入b的地址，或者创建一个json.RawMessage实例并赋值
rawMsg := json.RawMessage(b) // 将b转换为json.RawMessage类型
test := Data{"Hello", 1, &rawMsg} // 传入json.RawMessage的地址
b2, err := json.Marshal(test)
if err != nil {
fmt.Printf("Error marshaling Data: %s\n", err.Error())
return
}
fmt.Printf("包含RawMessage的结构体序列化结果 (b2): %s\n", string(b2))
// 预期输出: {"Name":"Hello","Id":1,"Json":{"Name":"World","Id":2}}
// 3. 反序列化外部结构体
var d Data
err = json.Unmarshal(b2, &d)
if err != nil {
fmt.Printf("Error unmarshaling b2 into Data: %s\n", err.Error())
return
}
// 确保d.Json不为nil再访问
if d.Json != nil {
fmt.Printf("反序列化后d.Json的内容: %s\n", string(*d.Json))
// 预期输出: {"Name":"World","Id":2}
} else {
fmt.Println("d.Json is nil after unmarshaling.")
}
// 4. 尝试解析d.Json字段
var tmp2 Data2
if d.Json != nil {
err = json.Unmarshal(*d.Json, &tmp2) // 对*d.Json进行反序列化
if err != nil {
fmt.Printf("Error unmarshaling d.Json into Data2: %s\n", err.Error())
return
}
fmt.Printf("解析后的Data2: %+v\n", tmp2)
// 预期输出: 解析后的Data2: {Name:World Id:2}
}
}运行修改后的代码，你会发现b2中的Json字段现在正确地包含了原始的JSON对象，而不是base64编码的字符串。后续对*d.Json的反序列化也能够成功执行。
注意事项与总结
- 类型选择：当需要在结构体中存储任意JSON片段并希望在序列化/反序列化过程中保持其原始JSON形式时，务必使用*json.RawMessage而非json.RawMessage。
- 空指针检查：由于*json.RawMessage是指针类型，在访问其内容之前，需要进行空指针检查，以避免运行时错误。
- 内存管理：json.RawMessage存储的是JSON的原始字节切片。如果JSON数据量很大，需要注意内存使用。
- 接口实现：json.RawMessage实现了json.Marshaler和json.Unmarshaler接口。当作为指针类型*json.RawMessage使用时，encoding/json包会正确地调用这些方法来处理JSON数据的编解码。
通过理解json.RawMessage的特性以及encoding/json包对其处理机制，我们可以有效地避免常见的二次编码陷阱，从而更灵活、高效地处理Go语言中的JSON数据。
