json的序列化与反序列化

序列化：将 Go 中的结构体、切片、map 等数据结构转换为 JSON 格式的字符串。

作用：方便数据在网络传输、文件保存等情境中使用。

反序列化：将 JSON 格式的字符串转换为 Go 的数据结构。

作用：方便从 JSON 中提取数据并在程序中使用。

JSON
{
“”： “”，
“”： “”，
“”： “”
}

Go中 使用 Marshal Unmarshal 进行序列化和反序列化

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    p := Person{Name: "Alice", Age: 25}

    // 序列化为 JSON
    jsonData, err := json.Marshal(p)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println(string(jsonData)) // 输出: {"name":"Alice","age":25}
}

---
}

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    jsonData := `{"name":"Alice","age":25}`

    var p Person

    // 反序列化为结构体
    err := json.Unmarshal([]byte(jsonData), &p)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println(p.Name, p.Age) // 输出: Alice 25
}

类比一下进程间管道通信：
在父子进程使用管道进行通信时，数据通常以字节流的形式传输。
要传递复杂数据结构，需要将数据转换为字节流（序列化），并在另一端解析回来（反序列化）。

GO中实现 字符进程通信

package main

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

type Message struct {
    Content string `json:"content"`
}

func main() {
    r, w, err := os.Pipe() // 创建管道
    if err != nil {
        fmt.Println("Error creating pipe:", err)
        return
    }

    if os.Getenv("IS_CHILD") == "1" {
        // 子进程逻辑
        r.Close() // 关闭写端
        var msg Message
        decoder := json.NewDecoder(r)
        if err := decoder.Decode(&msg); err != nil {
            fmt.Println("Error decoding:", err)
            return
        }
        fmt.Println("Child received:", msg.Content)
    } else {
        // 父进程逻辑
        w.Close() // 关闭读端
        cmd := os.Exec(os.Args[0], os.Args, os.Environ())
        cmd.Env = append(os.Environ(), "IS_CHILD=1")
        go func() {
            encoder := json.NewEncoder(w)
            encoder.Encode(Message{Content: "Hello, Child!"})
        }()
        cmd.Wait()
    }
}