Go语言流式数据JSON编码实践：避免内存一次性加载

package main

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

func main() {
    t := struct {
        Foo string
        Bar chan string // 这是一个数据流，不希望一次性加载
    }{
        Foo: "Hello World",
        Bar: make(chan string),
    }

    go func() {
        for _, x := range []string{"one", "two", "three"} {
            t.Bar <- x
        }
        close(t.Bar)
    }()

    // 尝试直接编码会导致错误：json: unsupported type: chan string
    if err := json.NewEncoder(os.Stdout).Encode(&t); err != nil {
        log.Println("Error:", err) // 实际会打印错误
    }
}

package main

import (
    "encoding/json"
    "io"
    "log"
    "os"
)

func main() {
    // 定义要编码的结构体，其中Bar是一个通道
    t := struct {
        Foo string
        Bar chan string
    }{
        Foo: "Hello World",
        Bar: make(chan string),
    }

    // 模拟一个数据流，向通道发送数据
    go func() {
        defer close(t.Bar) // 发送完毕后关闭通道
        for _, x := range []string{"one", "two", "three", "four", "five"} {
            t.Bar <- x
        }
    }()

    // 使用os.Stdout作为输出Writer
    w := os.Stdout
    err := streamEncodeStruct(w, t.Foo, t.Bar)
    if err != nil {
        log.Fatal(err)
    }
}

// streamEncodeStruct 函数负责将结构体内容流式编码为JSON
func streamEncodeStruct(w io.Writer, foo string, barChan <-chan string) error {
    // 写入JSON对象的开始部分和固定字段
    _, err := w.Write([]byte(`{"Foo":"`))
    if err != nil {
        return err
    }
    // 对foo字段的值进行JSON字符串转义（这里简化处理，实际应用中可能需要更严谨的转义）
    _, err = w.Write([]byte(jsonEscape(foo)))
    if err != nil {
        return err
    }
    _, err = w.Write([]byte(`","Bar":[`))
    if err != nil {
        return err
    }

    // 逐个处理通道中的数据
    firstElement := true
    for x := range barChan {
        if !firstElement {
            // 在每个元素前添加逗号，除了第一个
            _, err := w.Write([]byte(`,`))
            if err != nil {
                return err
            }
        } else {
            firstElement = false
        }

        // 使用json.NewEncoder编码单个元素
        // 注意：这里NewEncoder每次调用都会创建一个新的编码器，
        // 但由于我们只编码一个简单字符串，性能影响不大。
        // 对于复杂对象，Encoder可以复用。
        err := json.NewEncoder(w).Encode(x)
        if err != nil {
            return err
        }
    }

    // 写入JSON对象的结束部分
    _, err = w.Write([]byte(`]}`))
    if err != nil {
        return err
    }
    return nil
}

// jsonEscape 简单地对字符串进行JSON转义，实际生产中应使用更健壮的库函数
func jsonEscape(s string) string {
    // 简化的转义，实际应考虑所有特殊字符
    // encoding/json.Marshal("string") 可以提供完整的转义
    // 这里为了演示，直接使用一个简单替换
    s = `"` + s + `"` // 假设字符串内容不包含需要复杂转义的字符
    data, _ := json.Marshal(s)
    return string(data[1:len(data)-1]) // 移除外层引号
}

// 概念性代码，非实际可运行
// encoding/json/encode.go 内部的 reflectValueQuoted 函数中
// ...
case reflect.Array:
    e.WriteByte('[')
    n := v.Len()
    for i := 0; i < n; i++ {
        if i > 0 {
            e.WriteByte(',')
        }
        e.reflectValue(v.Index(i))
    }
    e.WriteByte(']')
case reflect.Chan: // 新增的通道处理逻辑
    e.WriteByte('[')
    i := 0
    for {
        // v.Recv() 会从通道中接收一个值
        // 如果通道关闭且没有更多值，ok 为 false
        x, ok := v.Recv()
        if !ok {
            break // 通道关闭，退出循环
        }
        if i > 0 {
            e.WriteByte(',')
        }
        // 递归调用 e.reflectValue 编码接收到的值
        e.reflectValue(x)
        i++
    }
    e.WriteByte(']')
// ...