使用 UnmarshalBSON 对动态接口进行解组的例子与已知密钥相关

大家好，我们又见面了啊~本文《使用 UnmarshalBSON 对动态接口进行解组的例子与已知密钥相关》的内容中将会涉及到等等。如果你正在学习Golang相关知识，欢迎关注我，以后会给大家带来更多Golang相关文章，希望我们能一起进步！下面就开始本文的正式内容~

我有一个 foo 类型的对象，其中包含一个 activationinterface 接口；该对象保存在 mongodb 中，由于内部对象的基础类型未知，我无法将其取回。

我按如下方式实现了 unmarshalbson 但没有成功，因为即使在设置了接口的具体类型之后，解组器现在仍然执行底层类型，因为我仍然收到错误： 解码关键行为错误：找不到 main.activationinterface 的解码器

你知道我该如何实现这一目标吗？

我在这里发现了一些接近工作的东西，所以我不明白为什么我的不是：unmarshaldynamic json based on a type key 我看不出我做错了什么以及有什么不同......！

编辑：我更新了代码以与 json 进行比较。 unmarshaljson 使用完全相同的代码可以很好地工作，而 unmarshalbson 仍然失败。

package main

import (
    "fmt"
    "log"

    "go.mongodb.org/mongo-driver/bson"
)

type foo struct {
    Type string `bson:"type"`
    Act  ActivationInterface
}

type ActivationInterface interface{}

type Activation1 struct {
    Name string `bson:"name"`
}
type Activation2 struct {
    Address string `bson:"adress"`
}

func (q *foo) UnmarshalBSON(data []byte) error {
    // Unmarshall only the type
    fooTemp := new(struct {
        Type string `bson:"type"`
    })
    if err := bson.Unmarshal(data, fooTemp); err != nil {
        return err
    }

    fmt.Println(fooTemp.Type)

    // Set the type to the prop
    switch fooTemp.Type {
    case "act1":
        // q.Act = &Activation1{}
        q.Act = new(Activation1)
    case "act2":
        // q.Act = &Activation2{}
        q.Act = new(Activation2)
    default:
        fmt.Println("DEFAULT")
    }

    // Call Unmarshal again
    type Alias foo // avoids infinite recursion using a type alias
    return bson.Unmarshal(data, (*Alias)(q))
}

func main() {
    foo1 := foo{
        Type: "act1",
        Act: Activation1{
            Name: "name: act1",
        },
    }
    foo2 := foo{
        Type: "act2",
        Act: Activation2{
            Address: "adress: act2",
        },
    }

    // Marshal
    m1, err := bson.Marshal(foo1)
    if err != nil {
        log.Fatal(err)
    }
    m2, err := bson.Marshal(foo2)
    if err != nil {
        log.Fatal(err)
    }
    //fmt.Println(m1, m2)

    // Unmarshal
    var u1, u2 foo
    err = bson.Unmarshal(m1, &u1)
    if err != nil {
        fmt.Println("1 -> ", err) // error decoding key act: no decoder found for main.ActivationInterface
    }
    err = bson.Unmarshal(m2, &u2)
    if err != nil {
        fmt.Println("2 -> ", err) // error decoding key act: no decoder found for main.ActivationInterface
    }
    fmt.Println(foo1.Type, ":", u1.Act.(*Activation1).Name)
    fmt.Println(foo2.Type, ":", u2.Act.(*Activation2).Address)
}

go演示：https://go.dev/play/p/bhmy6-zlsyq

几乎相同的代码，但使用 json 并工作：https://go.dev/play/p/v5hlrq_-ls3

谢谢！

正确答案

在结构中使用接口时，unmarshall 无法确定要选择哪个“实现”...您必须根据“类型”字段手动执行此操作。通常，unmarshall 方法会放置一个接口{} 的映射，即键值存储。 无论如何，回到你的问题，你必须将接口数据存储在 bson.raw （字节片）中，并通过选择正确的结构手动进行解组。

package main

import (
    "fmt"
    "log"

    "go.mongodb.org/mongo-driver/bson"
)

type foo struct {
    Type string `bson:"type"`
    Act  ActivationInterface
}

type ActivationInterface interface{}

type Activation1 struct {
    Name string `bson:"name"`
}
type Activation2 struct {
    Address string `bson:"adress"`
}

func (q *foo) UnmarshalBSON(data []byte) error {
    // Unmarshall only the type
    fooTemp := new(struct {
        Type string `bson:"type"`
        Act  bson.Raw
    })
    if err := bson.Unmarshal(data, fooTemp); err != nil {
        return err
    }

    fmt.Println(fooTemp.Type)

    // Set the type to the prop
    switch fooTemp.Type {
    case "act1":
        // q.Act = &Activation1{}
        a := Activation1{}
        err := bson.Unmarshal(fooTemp.Act, &a)
        if err != nil {
            return err
        }
        q.Act = a
    case "act2":
        // q.Act = &Activation2{}
        a := Activation2{}
        err := bson.Unmarshal(fooTemp.Act, &a)
        if err != nil {
            return err
        }
        q.Act = a
    default:
        fmt.Println("DEFAULT")
        return fmt.Errorf("unknown type: %v", fooTemp.Type)
    }

    return nil
}

func main() {
    foo1 := foo{
        Type: "act1",
        Act: Activation1{
            Name: "name: act1",
        },
    }
    foo2 := foo{
        Type: "act2",
        Act: Activation2{
            Address: "adress: act2",
        },
    }

    // Marshal
    m1, err := bson.Marshal(foo1)
    if err != nil {
        log.Fatal(err)
    }
    m2, err := bson.Marshal(foo2)
    if err != nil {
        log.Fatal(err)
    }
    //fmt.Println(m1, m2)

    // Unmarshal
    var u1, u2 foo
    err = bson.Unmarshal(m1, &u1)
    if err != nil {
        fmt.Println("1 -> ", err) // error decoding key act: no decoder found for main.ActivationInterface
    }
    err = bson.Unmarshal(m2, &u2)
    if err != nil {
        fmt.Println("2 -> ", err) // error decoding key act: no decoder found for main.ActivationInterface
    }
    fmt.Println(foo1.Type, ":", u1.Act.(Activation1).Name)
    fmt.Println(foo2.Type, ":", u2.Act.(Activation2).Address)
}

https://go.dev/play/p/CG2SlEknNrO

今天关于《使用 UnmarshalBSON 对动态接口进行解组的例子与已知密钥相关》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！