将平面 XML 转换为 go 数据结构

大家好，今天本人给大家带来文章《将平面 XML 转换为 go 数据结构》，文中内容主要涉及到，如果你对Golang方面的知识点感兴趣，那就请各位朋友继续看下去吧~希望能真正帮到你们，谢谢！

我有一个平面 xml 结构，我正在尝试将其解组为 go 数据结构。我正在尝试找到一种方法来获取每个存储桶中的项目列表（项目名称） 下面的 xml 即-bucket1 = [apple,orange,grapes],bucket2= [apple,mangoes]。

当我尝试将 xml 解组到下面的 go 数据结构中时，我能够获取存储桶名称和项目的列表，但我无法将项目列表映射到各自的存储桶，因为每个存储桶可以有许多项目。 有没有办法通过改变go数据结构来从这个xml中实现这个要求？我无法控制 xml 的结构，因此无法更改它以满足我的要求。 我是新来的，非常感谢这里的任何意见。

type buckets struct {
    XMLName    xml.Name `xml:"buckets"`
    BucketName []string `xml:"bucket-name"`
    ItemName   []string `xml:"item-name"`
    Weight     []string `xml:"weight"`
    Quantity   []string `xml:"quantity"`
}
        
    
    <?xml version="1.0" encoding="UTF-8"?>
    <buckets>
       <bucket-name>bucket1</bucket-name>
       <item-name>apple</item-name>
       <weight>500</weight>
       <quantity>3</quantity>
       <item-name>orange</item-name>
       <weight>500</weight>
       <quantity>2</quantity>
       <item-name>grapes</item-name>
       <weight>800</weight>
       <quantity>1</quantity>
       <bucket-name>bucket2</bucket-name>
       <item-name>apple</item-name>
       <weight>500</weight>
       <quantity>3</quantity>
       <item-name>mangoes</item-name>
       <weight>400</weight>
       <quantity>2</quantity>
    </buckets>

正确答案

您想要做的事情可以通过使用自定义 xml.unmarshalxml 并手动将存储桶映射到 go 结构来实现。

下面描述的代码假定 xml 元素的顺序与所提供的示例相同。

首先，我们有问题中描述的结构：

type buckets struct {
    xmlname xml.name `xml:"buckets"`
    buckets []*bucket
}

type bucket struct {
    bucketname string `xml:"bucket-name"`
    items      []*item
}

type item struct {
    name     string `xml:"item-name"`
    weight   int    `xml:"weight"`
    quantity int    `xml:"quantity"`
}

接下来，我们需要通过为 buckets 结构实现 unmarshalxml 方法来实现 Unmarshaler 接口。当我们调用 xml.unmarhsal 并将 buckets 结构作为目标传递时，将调用此方法。

func (b *buckets) unmarshalxml(d *xml.decoder, start xml.startelement) error {
    b.xmlname = start.name

    var currentbucket *bucket
    var currentitem *item
    for {
        t, err := d.token()
        if t == nil {
            // append the last bucket before exiting
            b.buckets = append(b.buckets, currentbucket)
            break
        }
        if err != nil {
            return err
        }
        switch se := t.(type) {
        case xml.startelement:
            switch se.name.local {
            case "bucket-name":
                // check if currentbucket is nil, it is necessary for the first time that
                // is going to run. otherwise, append the last bucket to the slice and reset it
                if currentbucket != nil {
                    b.buckets = append(b.buckets, currentbucket)
                }
                currentbucket = &bucket{}

                if err := d.decodeelement(&currentbucket.bucketname, &se); err != nil {
                    return err
                }
            case "item-name":
                currentitem = &item{}
                if err := d.decodeelement(&currentitem.name, &se); err != nil {
                    return err
                }
            case "weight":
                if err := d.decodeelement(&currentitem.weight, &se); err != nil {
                    return err
                }
            case "quantity":
                if err := d.decodeelement(&currentitem.quantity, &se); err != nil {
                    return err
                }

                // since quantity comes last append the item to the bucket,  and reset it
                currentbucket.items = append(currentbucket.items, currentitem)
                currentitem = &item{}
            }
        }
    }

    return nil
}

我们本质上所做的是循环 xml 元素并使用自定义逻辑将它们映射到我们的结构。我不会详细介绍 d.token() 和 xml.startelement，您可以随时阅读 docs 了解更多信息。

现在我们来分解一下上面的方法：

• 当我们遇到名为 bucket-name 的元素时，我们知道后面有一个新存储桶，因此将已处理的存储桶附加到切片（因为第一次不会有任何处理，我们必须检查 nil）到切片并将 currentbucket 设置为一个新的存储桶（我们要处理的存储桶）。
• 当我们遇到名为 item-name 的元素时，我们知道后面有一个新项目，因此将 currentitem 设置为新项目。
• 当我们遇到名为 quantity 的元素时，我们知道这是属于 currentitem 的最后一个元素，因此将其附加到 currentbucket.items
• 当 t 最终变为 nil 时，表示输入流结束，但由于每当遇到新的存储桶时我们都会附加一个存储桶，因此最后一个存储桶（或者如果只有一个存储桶）将不会被附加。因此，在 break 之前，我们需要附加最后处理的一个。

注释：

• 您可以完全避免 buckets 结构，并通过使用 xml.decoder 创建一个函数来处理解组，如下所示：

func UnmarshalBuckets(rawXML []byte) []*Bucket {
    // or any io.Reader that points to the xml data
    d := xml.NewDecoder(bytes.NewReader(rawXML))
    ...
}

免责声明：

• 我知道上面的代码感觉有点粗略，我相信您可以改进它。请随意使用它并以更易读的方式实现自定义逻辑。
• 应该有一些我没有涵盖或没有出现在提供的示例中的边缘情况。您应该分析您的 xml 并尝试（如果可能）覆盖它们。
• 正如已经提到的，代码严重依赖于 xml 元素的顺序。

Go Playground 的工作示例

我同意 mkopriva 的观点。 go 的注释针对用于相同结构的数据记录的 xml 进行了优化。将它们用于混合内容就像给牛套上马鞍一样。插件：我已经编写了处理 github 上混合内容的代码，欢迎提供反馈。

终于介绍完啦！小伙伴们，这篇关于《将平面 XML 转换为 go 数据结构》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！