使用接口解组结构切片

Question

我有一个非常有趣的案例，假设我们有这个结构体，

type Test struct {
 Field1 string `json:"field1"`
 Field2 ABC `json:"abc"`
}

type ABC interface {
  Rest()
}

解组这个结构体不是问题，您只需指向实现接口的正确结构体，除非您有 []Test

是否有当其中一个字段是接口时解组结构切片的方法？

谢谢

Answer 1

你需要实现Unmarshaler接口来测试，

然后在UnmarshalJSON函数中你需要一一检查它（示例中的第45-55行）

幸运的是现在有了通用，这是示例：

package main

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

type Test struct {
    Field1 string `json:"field1"`
    Field2 ABC    `json:"abc"`
}

type ABCImplements interface {
    A | B
}

func UnmarshalABC[T ABCImplements](b []byte) (T, error) {
    var x T
    err := json.Unmarshal(b, &x)
    if err != nil {
        return x, err
    }

    rv := reflect.ValueOf(x)
    if rv.IsZero() {
        return x, fmt.Errorf("T is zero value")
    }

    return x, nil
}

func (m *Test) UnmarshalJSON(data []byte) error {
    temp := make(map[string]interface{}, 2)
    err := json.Unmarshal(data, &temp)
    if err != nil {
        return err
    }
    m.Field1 = temp["field1"].(string)
    b, err := json.Marshal(temp["abc"])
    if err != nil {
        return err
    }

    xB, err := UnmarshalABC[B](b)
    if err == nil {
        m.Field2 = xB
        return nil
    }

    xA, err := UnmarshalABC[A](b)
    if err == nil {
        m.Field2 = &xA
        return nil
    }

    return nil
}

type A struct {
    B string `json:"b"`
}

func (a *A) Rest() {
    fmt.Println(a.B)
}

type B struct {
    C string `json:"c"`
}

func (b B) Rest() {
    fmt.Println(b.C)
}

type ABC interface {
    Rest()
}

func main() {
    a := &A{"coba"}
    t := Test{"oke", a}

    arrT := []Test{t, t, t}

    b, err := json.Marshal(arrT)
    if err != nil {
        panic(err)
    }

    var xT []Test
    err = json.Unmarshal(b, &xT)

    fmt.Printf("%#v\n", xT)
    fmt.Println(xT[1].Field2)
}

游乐场

Answer 2

使用以下代码将接口字段解组为特定的具体类型。有关更多详细信息，请参阅评论：

// Example is the concrete type.
type Example struct{ Hello string }
func (e *Example) Rest() {}

// Implement the json.Unmarshaler interface to control how
// values of type Test are unmarsheled.  
func (m *Test) UnmarshalJSON(data []byte) error {
    // Setup fields as needed.
    m.Field2 = &Example{}

    // We cannot call json.Unmarshal(data, m) to do the work
    // because the json.Unmarshal will recurse back to this 
    // function. To prevent the recursion, we declare a new 
    // type with the same field layout as Test, but no methods:
    type t Test

    // Convert receiver m to a t* and unmarshal using that pointer.
    v := (*t)(m)

    return json.Unmarshal(data, v)
}

在 Playground 上运行代码。