如何使用 mongo-go-driver marshal/unmarshal 具有多态结构的 bson 数组

Question

我正在努力 marshal/unmarshal bson array with polymorphic struct with mongo-go-driver。我计划将结构鉴别器保存到编组数据中，并编写一个自定义 UnmarshalBSONValue 函数来根据结构鉴别器对其进行解码。但我不知道如何正确地做到这一点。

package polymorphism

import (
    "fmt"
    "testing"

    "code.byted.org/gopkg/pkg/testing/assert"

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

type INode interface {
    GetName() string
}

type TypedNode struct {
    NodeClass string
}

type Node struct {
    TypedNode `bson:"inline"`
    Name      string
    Children  INodeList
}

func (n *Node) GetName() string {
    return n.Name
}

type INodeList []INode

func (l *INodeList) UnmarshalBSONValue(t bsontype.Type, data []byte) error {
    fmt.Println("INodeList.UnmarshalBSONValue")

    var arr []bson.Raw                // 1. First, try to decode data as []bson.Raw
    err := bson.Unmarshal(data, &arr) // error: cannot decode document into []bson.Raw
    if err != nil {
        fmt.Println(err)
        return err
    }
    for _, item := range arr { // 2. Then, try to decode each bson.Raw as concrete Node according to `nodeclass`
        class := item.Lookup("nodeclass").StringValue()
        fmt.Printf("class: %v\n", class)
        if class == "SubNode1" {
            bin, err := bson.Marshal(item)
            if err != nil {
                return err
            }
            var sub1 SubNode1
            err = bson.Unmarshal(bin, &sub1)
            if err != nil {
                return err
            }
            *l = append(*l, &sub1)
        } else if class == "SubNode2" {
            //...
        }
    }
    return nil
}

type SubNode1 struct {
    *Node     `bson:"inline"`
    FirstName string
    LastName  string
}

type SubNode2 struct {
    *Node `bson:"inline"`
    Extra string
}

使用上面的代码，我尝试将 INodeList 数据解码为 []bson.Raw，然后根据 nodeclass 将每个 bson.Raw 解码为具体节点。但是报错：

cannot decode document into []bson.Raw

第

行

err := bson.Unmarshal(data, &arr)。

那么，如何正确操作呢？

Answer 1

您需要将 bson.Raw 的指针传递给 bson.Unmarshal(data, &arr)，然后将其值切片为原始值数组，例如：

func (l *INodeList) UnmarshalBSONValue(t bsontype.Type, data []byte) error {
    fmt.Println("INodeList.UnmarshalBSONValue")

    var raw bson.Raw // 1. First, try to decode data as bson.Raw
    err := bson.Unmarshal(data, &raw)
    if err != nil {
        fmt.Println(err)
        return err
    }

    // Slice the raw document to an array of valid raw values
    rawNodes, err := raw.Values()
    if err != nil {
        return err
    }

    // 2. Then, try to decode each bson.Raw as concrete Node according to `nodeclass`
    for _, rawNode := range rawNodes {
        // Convert the raw node to a raw document in order to access its "nodeclass" field
        d, ok := rawNode.DocumentOK()
        if !ok {
            return fmt.Errorf("raw node can't be converted to doc")
        }
        class := d.Lookup("nodeclass").StringValue()

        // Decode the node's raw doc to the corresponding struct
        var node INode
        switch class {
        case "SubNode1":
            node = &SubNode1{}
        case "SubNode2":
            node = &SubNode2{}
        //...
        default:
            // ...
        }

        bson.Unmarshal(d, node)
        *l = append(*l, node)
    }

    return nil
}

注意Note.Children必须是INodeList的指针，inline fields必须是结构或映射（不是指针）：


type Node struct {
    TypedNode `bson:",inline"`
    Name      string
    Children  *INodeList
}

type SubNode1 struct {
    Node      `bson:",inline"`
    FirstName string
    LastName  string
}

type SubNode2 struct {
    Node  `bson:",inline"`
    Extra string
}

如何使用 mongo-go-driver marshal/unmarshal 具有多态结构的 bson 数组

How to marshal/unmarshal bson array with polymorphic struct with mongo-go-driver

go

mongodb

bson

mongo-go