Go语言中大规模数据流的JSON编码策略：避免内存溢出

package main

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

func main() {
    type Data struct {
        Foo string
        Bar chan string // 大量数据流，不希望一次性加载
    }

    t := Data{
        Foo: "Hello World",
        Bar: make(chan string),
    }

    // 模拟数据生成器
    go func() {
        defer close(t.Bar)
        for i, x := range []string{"one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"} {
            t.Bar <- x + fmt.Sprintf("-%d", i) // 添加索引以区分
            time.Sleep(50 * time.Millisecond) // 模拟数据生成延迟
        }
    }()

    // 尝试直接编码，会报错：json: unsupported type: chan string
    // if err := json.NewEncoder(os.Stdout).Encode(&t); err != nil {
    //     log.Printf("Error during direct encoding (expected): %v", err)
    // }
    // log.Println("Direct encoding failed as expected.")

    // ... (这里将引入手动编码解决方案)
}

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    "strconv" // 用于安全地引用字符串
    "time"
)

func main() {
    type Data struct {
        Foo string
        Bar chan string
    }

    t := Data{
        Foo: "Hello World",
        Bar: make(chan string),
    }

    go func() {
        defer close(t.Bar)
        for i, x := range []string{"one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"} {
            t.Bar <- x + fmt.Sprintf("-%d", i)
            time.Sleep(50 * time.Millisecond)
        }
    }()

    w := os.Stdout
    // 1. 写入JSON对象的起始部分，确保Foo的值被正确引用
    _, err := w.WriteString(fmt.Sprintf(`{"Foo":%s,"Bar":[`, strconv.Quote(t.Foo)))
    if err != nil {
        log.Fatal(err)
    }

    firstElement := true
    // 2. 遍历通道，处理每个元素
    for x := range t.Bar {
        if !firstElement {
            _, err = w.WriteString(`,`) // 3. 写入分隔符
            if err != nil {
                log.Fatal(err)
            }
        }
        // 编码单个元素，并直接写入。
        // 使用json.Marshal避免json.Encoder.Encode()自动添加换行符
        encodedX, err := json.Marshal(x)
        if err != nil {
            log.Fatal(err)
        }
        _, err = w.Write(encodedX)
        if err != nil {
            log.Fatal(err)
        }
        firstElement = false
    }

    // 4. 写入JSON数组和对象的结束部分
    _, err = w.WriteString(`]}`)
    if err != nil {
        log.Fatal(err)
    }
    w.WriteString("\n") // 确保输出完整
}

// 注意：以下代码仅为概念性伪代码，不应在生产环境中直接修改标准库。
// func (e *encodeState) reflectValue(v reflect.Value) {
//     switch v.Kind() {
//     // ... 现有类型处理，例如 reflect.Array ...
//     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('[') // 写入JSON数组的起始方括号
//         i := 0
//         for {
//             x, ok := v.Recv() // 从通道接收值
//             if !ok {
//                 break // 通道关闭，结束循环
//             }
//             if i > 0 {
//                 e.WriteByte(',') // 插入逗号分隔符
//             }
//             e.reflectValue(x) // 递归编码接收到的值
//             i++
//         }
//         e.WriteByte(']') // 写入JSON数组的结束方括号
//     // ... 其他类型处理 ...
//     }
// }