如何为嵌套结构体的UnmarshalJSON实现传递额外上下文/状态？

首先，你的需求完全可以实现，下面我给你梳理几个可行的方案，其中第一种是最简洁且符合Go设计风格的：

问题回顾 #

我的HTTP请求处理器依赖外部服务返回的JSON数据进行反序列化，过程中希望通过自定义的UnmarshalJSON方法影响实例状态，但需要让该方法能够访问当前请求的上下文（request.Context）或请求作用域状态。请问是否可以实现？是否有我忽略的简便方法？

你的代码场景中，核心矛盾是标准库的json.Unmarshal/json.Decoder无法直接将上下文传递给嵌套结构体的UnmarshalJSON方法——因为该方法的签名是固定的：func (f *Foo) UnmarshalJSON(data []byte) error，没有额外参数位置传递上下文。

方案一：自定义带上下文的反序列化方法（推荐） #

绕过标准库的UnmarshalJSON限制，给Foo新增一个带上下文参数的反序列化方法，然后手动拆分顶层结构和嵌套结构的解码流程：

// foo.go
type FooList struct {
    Fools []*Foo `json:"list"`
}

type Foo struct {
    // 你的原有字段
    Name string `json:"name"`
}

// 新增带上下文的反序列化方法，替代原有的UnmarshalJSON
func (f *Foo) UnmarshalWithContext(ctx context.Context, data []byte) error {
    // 这里可以直接访问请求上下文了！
    if reqID := ctx.Value("request-id"); reqID != nil {
        // 示例：根据请求ID修改Foo的状态
        f.Name = fmt.Sprintf("%s (req: %v)", f.Name, reqID)
    }

    // 先完成常规的JSON反序列化（用临时类型避免递归调用）
    type tempFoo Foo
    var tf tempFoo
    if err := json.Unmarshal(data, &tf); err != nil {
        return err
    }
    *f = Foo(tf)

    return nil
}

// handler.go
func handleSomething(w http.ResponseWriter, r *http.Request) {
    go func(r *http.Request) {
        resp, err := httpClient.Do(...) // 调用外部服务
        if err != nil {
            // 错误处理
            return
        }
        defer resp.Body.Close()

        // 1. 先解码顶层结构，把Foo的JSON数据保留为RawMessage，不触发自定义逻辑
        type tempFooList struct {
            Fools []json.RawMessage `json:"list"`
        }
        var tfl tempFooList
        if err := json.NewDecoder(resp.Body).Decode(&tfl); err != nil {
            // 错误处理
            return
        }

        // 2. 遍历每个Foo的Raw数据，用带上下文的方法解码
        fools := &FooList{}
        fools.Fools = make([]*Foo, len(tfl.Fools))
        for i, rawFoo := range tfl.Fools {
            foo := &Foo{}
            // 传递请求上下文到自定义方法
            if err := foo.UnmarshalWithContext(r.Context(), rawFoo); err != nil {
                // 错误处理
                return
            }
            fools.Fools[i] = foo
        }

        // 后续使用fools...
    }(r)
}

这个方案的优势：

• 显式传递上下文，符合Go的"显式优于隐式"设计哲学
• 没有循环引用或全局状态的问题
• 逻辑清晰，容易维护

方案二：让Foo持有FooList的引用（可选） #

如果希望保留UnmarshalJSON方法，可以让Foo持有指向FooList的指针，通过FooList间接访问请求对象，但需要手动关联引用：

// foo.go
type FooList struct {
    Fools []*Foo `json:"list"`
    Req   *http.Request
}

type Foo struct {
    // 原有字段
    list *FooList // 持有FooList的引用
}

func (f *Foo) UnmarshalJSON(data []byte) error {
    // 通过f.list.Req拿到请求上下文
    ctx := f.list.Req.Context()

    // 常规反序列化逻辑
    type tempFoo Foo
    var tf tempFoo
    if err := json.Unmarshal(data, &tf); err != nil {
        return err
    }
    *f = Foo(tf)
    f.list = tf.list // 保持引用关联

    // 使用ctx处理自定义逻辑...
    return nil
}

// handler.go
func handleSomething(w http.ResponseWriter, r *http.Request) {
    go func(r *http.Request) {
        fools := &FooList{Req: r}
        resp, err := httpClient.Do(...)
        if err != nil {
            return
        }
        defer resp.Body.Close()

        // 先解码Foo的原始数据，再关联引用
        type tempFooList struct {
            Fools []json.RawMessage `json:"list"`
        }
        var tfl tempFooList
        if err := json.NewDecoder(resp.Body).Decode(&tfl); err != nil {
            return
        }

        fools.Fools = make([]*Foo, len(tfl.Fools))
        for i, rawFoo := range tfl.Fools {
            // 先给Foo设置list引用，再解码
            foo := &Foo{list: fools}
            if err := json.Unmarshal(rawFoo, foo); err != nil {
                return
            }
            fools.Fools[i] = foo
        }
    }(r)
}

这个方案需要注意：必须在解码前给Foo设置list引用，否则UnmarshalJSON执行时拿不到请求对象，逻辑相对绕一些。

不推荐的方案：全局临时存储上下文 #

有些开发者会尝试用全局sync.Map结合goroutine ID来临时存储上下文，但这种方法存在并发安全隐患（比如goroutine复用），而且不符合Go的设计风格，非常不推荐。

内容的提问来源于stack exchange，提问作者hans0l074