如何利用reflect.Value反序列化JSON切片中的单个元素？

我从HTTP请求中读取JSON数据，该JSON是Account结构体的切片。当JSON存在拼写错误或其他问题时，我希望解析JSON并向客户端返回有用的错误信息。

我先使用[]jsontext.Value分离各个Account结构体，之后再对每个Account结构体反序列化以检查语义错误。在测试代码中，第一个对象的Account.name属性被误写为Account.name_，以此触发parse_semantic_errors()函数。

但在反序列化切片中的每个元素时，返回了如下错误：

json: cannot unmarshal Go value of type reflect.Value

请问如何利用反射获取的input := elem.Index(0)来反序列化切片中的每个元素？

测试代码 #

package main

import (
  "errors"
  "fmt"
  "reflect"

  "github.com/go-json-experiment/json"
  "github.com/go-json-experiment/json/jsontext"
)

type Account struct {
  Name  *string `json:"name"`
  Email *string `json:"email"`
}

func main() {
  inputs := []Account{}
  err := parse_json(&inputs)
  if err != nil {
    return
  }
  for i, entry := range inputs {
    fmt.Println(i, *entry.Name, *entry.Email)
  }
}

func parse_json(inputs any) error {
  b := []byte(`[{"name_":"user1","email":"email1"},{"name":"user2","email":"email2"}]`)
  err := json.Unmarshal(b, &inputs, json.RejectUnknownMembers(true))
  if err != nil {
    fmt.Println("err:", err)
    var serr *json.SemanticError
    if errors.As(err, &serr) {
      parse_semantic_errors(b, inputs)
      return serr
    }
  }
  return err
}

func parse_semantic_errors(b []byte, inputs any) {
  fmt.Println("parsing semantic error")
  
  elem := reflect.ValueOf(inputs).Elem()
  if elem.Kind() != reflect.Slice {
    fmt.Println("Input is not a slice")
    return
  }
  
  // First object in inputs slice
  input := elem.Index(0)
  fmt.Println("first item in inputs slice:", input)
  
  body, serr := get_request_body_slice(b)
  if serr != nil {
    fmt.Println("err:", serr)
    return
  }
  fmt.Println("jsontext slice:", body)
  
  for _, b := range body {
    if err := json.Unmarshal(b, &input, json.RejectUnknownMembers(true)); err != nil {
      fmt.Println("err:", err)
    }
    fmt.Println(input)
  }
}

func get_request_body_slice(b []byte) ([]jsontext.Value, error) {
  var body []jsontext.Value
  if err := json.Unmarshal(b, &body); err != nil {
    return nil, fmt.Errorf("Request body must be an array")
  }
  return body, nil
}

错误根源是你传递给json.Unmarshal的是reflect.Value的地址，而非目标结构体实例的地址。elem.Index(0)返回的是reflect.Value类型值，直接取地址得到的是*reflect.Value，这不符合反序列化所需的目标类型指针要求。

修正步骤 #

1. 不要复用切片中已有的元素，而是为每个JSON元素创建对应类型的新实例，避免覆盖问题。
2. 使用reflect.New()创建元素类型的指针，再通过Elem()获取实例的reflect.Value，最后用Addr().Interface()得到可用于反序列化的指针接口。

修改后的parse_semantic_errors函数：

func parse_semantic_errors(b []byte, inputs any) {
  fmt.Println("parsing semantic error")
  
  elem := reflect.ValueOf(inputs).Elem()
  if elem.Kind() != reflect.Slice {
    fmt.Println("Input is not a slice")
    return
  }
  
  body, serr := get_request_body_slice(b)
  if serr != nil {
    fmt.Println("err:", serr)
    return
  }
  fmt.Println("jsontext slice:", body)
  
  // 遍历每个JSON元素，独立解析
  for idx, item := range body {
    // 创建切片元素类型的新实例
    elemType := elem.Type().Elem()
    newItem := reflect.New(elemType).Elem()
    
    // 传递实例的指针接口进行反序列化
    if err := json.Unmarshal(item, newItem.Addr().Interface(), json.RejectUnknownMembers(true)); err != nil {
      fmt.Printf("第%d个元素解析错误: %v\n", idx, err)
    } else {
      fmt.Printf("第%d个元素解析结果: %+v\n", idx, newItem.Interface())
    }
  }
}

这样修改后，既能正确反序列化每个JSON元素，还能精准定位到出错的元素位置，便于向客户端返回更清晰的错误提示。

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