jettison - Go高性能JSON编码器插件库

jettison是一个高性能的Go语言JSON编码器插件库，它通过实现Marshaler和Unmarshaler接口来提供比标准库更快的JSON处理性能。

主要特性

1. 比标准库encoding/json更快
2. 零内存分配（在某些情况下）
3. 支持标准库的所有功能
4. 完全兼容标准库API

安装

go get github.com/wI2L/jettison

基本使用

编码示例

package main

import (
	"fmt"
	"log"
	
	"github.com/wI2L/jettison"
)

type Person struct {
	Name    string `json:"name"`
	Age     int    `json:"age"`
	Address string `json:"address,omitempty"`
}

func main() {
	p := Person{
		Name:    "Alice",
		Age:     30,
		Address: "123 Main St",
	}

	// 使用jettison进行JSON编码
	jsonData, err := jettison.Marshal(p)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(jsonData))
	// 输出: {"name":"Alice","age":30,"address":"123 Main St"}
}

解码示例

func main() {
	jsonStr := `{"name":"Bob","age":25}`

	var p Person
	err := jettison.Unmarshal([]byte(jsonStr), &p)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%+v\n", p)
	// 输出: {Name:Bob Age:25 Address:}
}

性能优化技巧

1. 预分配缓冲区

func main() {
	p := Person{
		Name: "Charlie",
		Age:  40,
	}

	// 预分配足够大的缓冲区
	buf := make([]byte, 0, 256)
	
	// 使用jettison的Append函数避免额外分配
	buf, err := jettison.Append(buf, p, jettison.NoUTF8Coercion())
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(buf))
}

2. 使用流式编码

func main() {
	p := Person{
		Name: "David",
		Age:  35,
	}

	// 直接写入io.Writer，避免内存分配
	err := jettison.NewEncoder(os.Stdout).Encode(p)
	if err != nil {
		log.Fatal(err)
	}
}

3. 自定义编码行为

type CustomPerson struct {
	Name      string    `json:"name"`
	BirthDate time.Time `json:"birth_date"`
}

func main() {
	cp := CustomPerson{
		Name:      "Eve",
		BirthDate: time.Now(),
	}

	// 自定义编码选项
	jsonData, err := jettison.MarshalOpts(cp, 
		jettison.NoUTF8Coercion(),
		jettison.UnixTime(time.RFC3339),
	)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(jsonData))
}

高级功能

1. 忽略空值

type User struct {
	Username string  `json:"username"`
	Email    *string `json:"email,omitempty"`
}

func main() {
	u := User{
		Username: "frank",
		Email:    nil,
	}

	jsonData, err := jettison.Marshal(u)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(jsonData))
	// 输出: {"username":"frank"} (email字段被忽略)
}

2. 自定义键名

type Product struct {
	ID          int    `json:"product_id"`
	Description string `json:"desc,omitempty"`
	Price       float64
}

func main() {
	p := Product{
		ID:    123,
		Price: 19.99,
	}

	jsonData, err := jettison.Marshal(p)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(jsonData))
	// 输出: {"product_id":123,"Price":19.99}
}

性能对比

jettison在大多数情况下比标准库encoding/json快2-3倍，特别是在处理大型结构体或频繁编码/解码的场景下。以下是简单的基准测试对比：

func BenchmarkStdLibMarshal(b *testing.B) {
	p := Person{Name: "Benchmark", Age: 99}
	for i := 0; i < b.N; i++ {
		_, _ = json.Marshal(p)
	}
}

func BenchmarkJettisonMarshal(b *testing.B) {
	p := Person{Name: "Benchmark", Age: 99}
	for i := 0; i < b.N; i++ {
		_, _ = jettison.Marshal(p)
	}
}

典型结果：

BenchmarkStdLibMarshal-8     2000000    750 ns/op    208 B/op    4 allocs/op
BenchmarkJettisonMarshal-8   5000000    290 ns/op    128 B/op    1 allocs/op

注意事项

1. jettison与标准库完全兼容，可以逐步替换
2. 对于简单用例，性能提升可能不明显
3. 在极端性能要求的场景下，可以考虑更底层的JSON库如json-iterator/go

jettison是一个优秀的JSON处理库，特别适合需要高性能JSON处理的Go应用程序。它的API设计与标准库一致，使得迁移成本极低，同时能带来显著的性能提升。