![go语言中将[]uint8或[]byte序列化为json数字数组的策略](https://img.php.cn/upload/article/001/246/273/175894345931093.jpg)
默认行为与问题背景
Go语言的encoding/json包在处理[]byte类型时，有一个特殊的规则：它不会将其视为普通的切片（slice）并编码为JSON数组，而是将其视为字节流，并使用Base64编码将其转换为JSON字符串。例如，一个包含[]uint8{'h', 'e', 'l', 'l', 'o'}的结构体，在默认序列化后，[]uint8部分会被编码为"aGVsbG8="这样的Base64字符串，而不是[104,101,108,108,111]这样的数字数组。当我们需要将这些字节表示为数字数组时，就需要自定义序列化逻辑。
解决方案：实现json.Marshaler接口
json.Marshaler接口提供了一个MarshalJSON() ([]byte, error)方法，允许我们完全控制特定类型如何被序列化为JSON。通过实现这个接口，我们可以重写[]uint8的默认序列化行为。
策略一：在包含[]uint8的结构体上实现MarshalJSON
这种方法适用于当[]uint8字段只在特定结构体中使用，且该结构体的JSON序列化逻辑需要特殊定制时。
package main
import (
"encoding/json"
"fmt"
"strings"
)
// Test 结构体包含一个字符串字段和一个[]uint8字段
type Test struct {
Name string
Array []uint8
}
// MarshalJSON 为Test类型实现json.Marshaler接口
func (t *Test) MarshalJSON() ([]byte, error) {
var arrayStr string
if t.Array == nil {
// 如果切片为nil，则JSON表示为null
arrayStr = "null"
} else {
// 将[]uint8转换为形如 "[104 101 108 108 111]" 的字符串
// strings.Fields会将其分割成 [" [104", "101", "108", "108", "111] "]
// strings.Join再用逗号连接，得到 "[104,101,108,108,111]"
arrayStr = strings.Join(strings.Fields(fmt.Sprintf("%d", t.Array)), ",")
}
// 使用fmt.Sprintf构建最终的JSON字符串
// %q 格式化字符串为带双引号的JSON字符串
// %s 格式化arrayStr为原始字符串，因为arrayStr已经包含了JSON数组的括号
jsonResult := fmt.Sprintf(`{"Name":%q,"Array":%s}`, t.Name, arrayStr)
return []byte(jsonResult), nil
}
func main() {
// 示例1: 包含有效[]uint8的结构体
t1 := &Test{"Go", []uint8{'h', 'e', 'l', 'l', 'o'}}
m1, err := json.Marshal(t1)
if err != nil {
fmt.Println("Error marshaling t1:", err)
}
fmt.Printf("Marshaled t1: %s\n", m1) // {"Name":"Go","Array":[104,101,108,108,111]}
// 示例2: 包含nil []uint8的结构体
t2 := &Test{"NilArray", nil}
m2, err := json.Marshal(t2)
if err != nil {
fmt.Println("Error marshaling t2:", err)
}
fmt.Printf("Marshaled t2: %s\n", m2) // {"Name":"NilArray","Array":null}
// 示例3: 包含空[]uint8的结构体 (空切片与nil切片不同)
t3 := &Test{"EmptyArray", []uint8{}}
m3, err := json.Marshal(t3)
if err != nil {
fmt.Println("Error marshaling t3:", err)
}
fmt.Printf("Marshaled t3: %s\n", m3) // {"Name":"EmptyArray","Array":[]}
}代码解析：
立即学习“go语言免费学习笔记（深入）”；
- fmt.Sprintf("%d", t.Array)：这会将[]uint8切片格式化成一个字符串，例如[]uint8{'h', 'e', 'l', 'l', 'o'}会变成"[104 101 108 108 111]"。
- strings.Fields(...)：这个函数会根据空白字符将字符串分割成一个字符串切片。对于"[104 101 108 108 111]"，它会产生["[104", "101", "108", "108", "111]"]。
- strings.Join(..., ",")：这个函数会将字符串切片中的元素用逗号连接起来，最终得到"[104,101,108,108,111]"。
- fmt.Sprintf({"Name":%q,"Array":%s}, t.Name, arrayStr)：最后，使用fmt.Sprintf将Name字段（使用%q进行JSON字符串安全编码）和处理过的Array字符串（使用%s直接插入，因为它已经是一个合法的JSON数组字符串）组合成完整的JSON输出。
- nil处理：在MarshalJSON方法中，我们显式检查t.Array是否为nil。如果为nil，则将其序列化为JSON null；否则，按上述逻辑将其序列化为数字数组。对于空切片[]uint8{}，fmt.Sprintf("%d", []uint8{})会得到"[]"，经过strings.Fields和strings.Join后仍然是"[]"，符合JSON空数组的表示。
策略二：创建自定义类型并实现MarshalJSON
这种方法更具通用性和可重用性。当多个结构体或多个地方需要将[]uint8序列化为JSON数字数组时，可以定义一个包装类型，并为其实现MarshalJSON。
package main
import (
"encoding/json"
"fmt"
"strings"
)
// JSONableUint8Slice 是一个基于[]uint8的自定义类型
type JSONableUint8Slice []uint8
// MarshalJSON 为JSONableUint8Slice类型实现json.Marshaler接口
func (u JSONableUint8Slice) MarshalJSON() ([]byte, error) {
var result string
if u == nil {
// 如果切片为nil，则JSON表示为null
result = "null"
} else {
// 逻辑与策略一相同，将[]uint8转换为JSON数字数组字符串
result = strings.Join(strings.Fields(fmt.Sprintf("%d", u)), ",")
}
return []byte(result), nil
}
// AnotherTest 结构体使用自定义的JSONableUint8Slice类型
type AnotherTest struct {
Name string
Data JSONableUint8Slice
Value int
}
func main() {
// 示例1: 包含有效数据的结构体
at1 := &AnotherTest{"GoLang", []uint8{'w', 'o', 'r', 'l', 'd'}, 123}
m1, err := json.Marshal(at1)
if err != nil {
fmt.Println("Error marshaling at1:", err)
}
fmt.Printf("Marshaled at1: %s\n", m1) // {"Name":"GoLang","Data":[119,111,114,108,100],"Value":123}
// 示例2: 包含nil切片的结构体
at2 := &AnotherTest{"NilData", nil, 456}
m2, err := json.Marshal(at2)
if err != nil {
fmt.Println("Error marshaling at2:", err)
}
fmt.Printf("Marshaled at2: %s\n", m2) // {"Name":"NilData","Data":null,"Value":456}
}代码解析：
立即学习“go语言免费学习笔记（深入）”；
- type JSONableUint8Slice []uint8：定义了一个名为JSONableUint8Slice的新类型，其底层类型是[]uint8。
- func (u JSONableUint8Slice) MarshalJSON() ([]byte, error)：为这个新类型实现了MarshalJSON方法。其内部逻辑与策略一中处理Array字段的逻辑完全相同。
- 现在，任何需要将[]uint8序列化为JSON数字数组的结构体字段，都可以直接使用JSONableUint8Slice类型。
这种方法的好处在于：
- 代码重用：JSONableUint8Slice可以在多个结构体中复用，避免重复编写相同的序列化逻辑。
- 关注点分离：将[]uint8的特殊序列化逻辑封装在JSONableUint8Slice类型中，使得结构体本身的定义更简洁，专注于业务数据。
- 类型安全：明确地为需要特殊处理的[]uint8字段指定了类型，提高了代码的可读性和维护性。
注意事项与总结
- nil和空切片：在实现MarshalJSON时，务必考虑nil切片和空切片[]uint8{}的区别。通常，nil切片应序列化为JSON null，而空切片应序列化为JSON []。上述两种策略都正确处理了这两种情况。
-
性能考量：上述解决方案中，fmt.Sprintf、strings.Fields和strings.Join涉及多次字符串分配和操作。对于非常大的[]uint8切片，这可能会带来一定的性能开销。在对性能要求极高的场景下，可以考虑手动遍历[]uint8并使用bytes.Buffer或strings.Builder来构建JSON字符串，以减少中间字符串的创建。
例如，可以这样手动构建：
var b strings.Builder b.WriteString("[") for i, v := range u { if i > 0 { b.WriteString(",") } b.WriteString(strconv.Itoa(int(v))) // 需要导入 "strconv" } b.WriteString("]") return []byte(b.String()), nil - 错误处理：在实际应用中，MarshalJSON方法内部可能会有更复杂的逻辑，需要进行适当的错误检查和返回。
- 反序列化（json.Unmarshaler）：如果不仅需要序列化，还需要将JSON数字数组反序列化回[]uint8，那么还需要实现json.Unmarshaler接口，提供UnmarshalJSON([]byte) error方法。
通过实现json.Marshaler接口，Go语言开发者可以灵活地控制自定义类型的JSON序列化行为，从而满足特定的数据格式需求，即使面对[]byte这种有特殊默认处理的类型也能轻松应对。选择哪种策略取决于具体的应用场景和代码组织偏好。
