Go语言中处理嵌套JSON数据：以goweb框架为例

type Thing struct {
    Id   string
    Text string
}

type ThingText struct {
    Title string
    Body  string
}

type Thing struct {
    Id   string
    Text ThingText // 嵌套结构
}

package main

import (
    "fmt"
    "net/http"

    "github.com/stretchr/goweb"
    "github.com/stretchr/goweb/context"
)

// 定义嵌套结构
type ThingText struct {
    Title string
    Body  string
}

type Thing struct {
    Id   string
    Text ThingText
}

// 模拟存储
var things = make(map[string]*Thing)

func main() {
    goweb.Map("/things", func(c *context.Context) error {
        // HTTP POST 请求，用于创建Thing
        if c.Method() == http.MethodPost {
            return CreateThing(c)
        }
        // 其他HTTP方法（如GET）的逻辑
        return c.NoContent()
    })

    // 启动服务器
    http.ListenAndServe(":9090", goweb.DefaultHttpHandler())
}

func CreateThing(c *context.Context) error {
    // 获取请求数据，goweb通常将其解析为interface{}
    data := c.RequestData()

    // 将数据断言为顶层map[string]interface{}
    dataMap, ok := data.(map[string]interface{})
    if !ok {
        return c.RespondWith(400, nil, "Invalid request data format")
    }

    thing := new(Thing)

    // 访问Id字段
    if id, ok := dataMap["Id"].(string); ok {
        thing.Id = id
    } else {
        return c.RespondWith(400, nil, "Id is missing or invalid")
    }

    // 访问嵌套的Text字段，它是一个map[string]interface{}
    if textData, ok := dataMap["Text"].(map[string]interface{}); ok {
        // 从嵌套的map中访问Title字段
        if title, ok := textData["Title"].(string); ok {
            thing.Text.Title = title
        } else {
            return c.RespondWith(400, nil, "Text.Title is missing or invalid")
        }
        // 从嵌套的map中访问Body字段
        if body, ok := textData["Body"].(string); ok {
            thing.Text.Body = body
        } else {
            return c.RespondWith(400, nil, "Text.Body is missing or invalid")
        }
    } else {
        return c.RespondWith(400, nil, "Text object is missing or invalid")
    }

    // 存储或处理thing
    things[thing.Id] = thing
    fmt.Printf("Created Thing: %+v\n", thing)

    return c.RespondWith(200, thing, nil)
}

curl -X POST -H "Content-Type: application/json" -d '{"Id":"TestId","Text":{"Title":"TestTitle","Body":"TestBody"}}' http://localhost:9090/things

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"

    "github.com/stretchr/goweb"
    "github.com/stretchr/goweb/context"
)

// 定义嵌套结构（与方法一相同）
type ThingText struct {
    Title string `json:"Title"` // 可选：使用json tag明确映射JSON字段名
    Body  string `json:"Body"`
}

type Thing struct {
    Id   string    `json:"Id"`
    Text ThingText `json:"Text"`
}

// 模拟存储
var things = make(map[string]*Thing)

func main() {
    goweb.Map("/things", func(c *context.Context) error {
        if c.Method() == http.MethodPost {
            return CreateThingWithUnmarshal(c)
        }
        return c.NoContent()
    })

    http.ListenAndServe(":9090", goweb.DefaultHttpHandler())
}

func CreateThingWithUnmarshal(c *context.Context) error {
    var thing Thing

    // 从请求体中直接读取JSON数据并解码到结构体
    // 注意：这里直接访问了c.Request().Body，而不是goweb处理后的c.RequestData()
    // 这样做可以绕过goweb可能进行的初步解析，直接使用encoding/json
    decoder := json.NewDecoder(c.Request().Body)
    err := decoder.Decode(&thing)
    if err != nil {
        if err == io.EOF {
            return c.RespondWith(400, nil, "Empty request body")
        }
        return c.RespondWith(400, nil, fmt.Sprintf("Failed to decode JSON: %v", err))
    }

    // 验证必要字段（可选，但推荐）
    if thing.Id == "" {
        return c.RespondWith(400, nil, "Id field is required")
    }
    if thing.Text.Title == "" {
        return c.RespondWith(400, nil, "Text.Title field is required")
    }

    // 存储或处理thing
    things[thing.Id] = &thing
    fmt.Printf("Created Thing (Unmarshal): %+v\n", thing)

    return c.RespondWith(200, thing, nil)
}