Go xml.Decoder.DecodeElement 怎样读取嵌套节点

处理一份很大的 XML 时，通常不需要先把整份文档反序列化成一个大对象。更实用的做法是让 xml.Decoder 按 token 向前读取，遇到目标元素的 StartElement 后，再把这个起始标记交给 DecodeElement。它会按照 Unmarshal 的规则读取当前元素、属性、文本和嵌套子节点，返回后外层循环可以继续读后面的内容。

关键只有一句：不要把当前 StartElement 先消费掉，也不要先调用 Skip；在确认它是目标节点后，直接执行 decoder.DecodeElement(&value, &start)。

本文只讨论 Token 循环中读取嵌套节点的写法，不展开 XML 命名空间设计。示例把订单节点作为目标，演示如何保留流式读取的优点，同时让结构体负责处理内部层级。

先看清 Token 循环里的问题现场

假设 XML 中有很多订单，每个订单内部还包含客户、收货地址和明细。调用 Token() 后，解码器每次只返回一个 token：可能是开始元素、结束元素、字符数据或其他标记。我们只想在遇到 order 时读取这一整个局部节点，而不是手动维护每一层的深度。

林青杭州2

如果在读到 后继续手动调用 Token()，就要自己判断何时进入或离开 customer、shipping 和 items。节点一多，深度计数、属性读取和异常返回很容易混在一起。

结构体先把嵌套关系表达清楚

DecodeElement 的第二个参数表示当前要解码的开始元素，目标值则可以是带有 XML 标签的结构体指针。属性使用 ,attr，普通子元素直接写名称，数组字段表示同名元素可以重复出现。

package main

import "encoding/xml"

type Order struct {
    XMLName  xml.Name `xml:"order"`
    ID       string   `xml:"id,attr"`
    Customer Customer `xml:"customer"`
    Shipping Shipping `xml:"shipping"`
    Items    []Item   `xml:"items>item"`
}

type Customer struct {
    Name string `xml:"name"`
}

type Shipping struct {
    City string `xml:"city"`
}

type Item struct {
    SKU      string `xml:"sku,attr"`
    Quantity int    `xml:"quantity"`
}

这里的 Items 使用 items>item，表示先进入 items，再收集其中的多个 item。字段必须是导出的，字段名或标签要和 XML 名称对应，否则解码器不会把值写入不可见字段。

找到 StartElement 后直接调用 DecodeElement

真正的读取逻辑可以保持在一个很小的循环里。先处理 io.EOF，再把 token 断言为 xml.StartElement；只有名称匹配时才创建目标结构体并调用 DecodeElement。

package main

import (
    "encoding/xml"
    "fmt"
    "io"
    "strings"
)

func readOrders(data string) ([]Order, error) {
    decoder := xml.NewDecoder(strings.NewReader(data))
    orders := make([]Order, 0, 4)

    for {
        token, err := decoder.Token()
        if err == io.EOF {
            // 输入正常结束，返回已经收集到的订单。
            return orders, nil
        }
        if err != nil {
            // XML 语法错误或底层读取错误不能当成正常结束。
            return nil, fmt.Errorf("读取 XML token 失败: %w", err)
        }

        start, ok := token.(xml.StartElement)
        if !ok || start.Name.Local != "order" {
            // 非目标开始元素交给外层循环继续处理。
            continue
        }

        var order Order
        // DecodeElement 会消费当前 order 的整个嵌套子树。
        if err := decoder.DecodeElement(&order, &start); err != nil {
            return nil, fmt.Errorf("解码订单 %q 失败: %w", order.ID, err)
        }
        orders = append(orders, order)
    }
}

这段代码里，start 是从当前 token 得到的值，传参时要取它的地址。DecodeElement 返回后，当前 order 的子节点和匹配的结束元素已经被消费，下一次 Token() 会继续从外层后续位置读取。

为什么不能先 Skip 或多读一个 Token

问题通常出在消费边界：已经拿到目标 StartElement 后再调用一次 Token()，会把目标节点的第一个内部 token 提前取走；如果先调用 Skip()，则整个节点会被跳过，之后再调用 DecodeElement 已经没有完整子树可读。

手动遍历当然可以，但它要求调用方自己读取所有嵌套 token，并处理匹配的 EndElement。选择 DecodeElement 时，应把“找到目标开始元素”和“解码它的完整局部结构”看作一次交接。

错误处理要分清结束、语法和解码失败

io.EOF 只表示输入已经正常读完，不代表当前节点解码成功。Token() 返回其他错误时，应保留原始错误；DecodeElement 返回错误时，则说明当前目标元素的内容无法按结构体规则落地，应该带上节点上下文后返回或记录。

如果 XML 允许某些字段缺失，结构体的零值可能是合理结果；如果字段缺失必须报错，就要在解码后增加业务层判断，例如检查订单号、客户名或明细数量。这个判断属于业务规则，不要和 XML token 循环混成一层。

用三个检查点复查读取结果

1. 确认只在目标 StartElement 上调用 DecodeElement，没有提前调用 Skip 或额外读取内部 token。
2. 确认属性标签、嵌套路径和切片字段与 XML 层级一致，字段名使用导出形式。
3. 确认 io.EOF、Token 错误和 DecodeElement 错误分别处理，返回成功时外层循环已经越过当前节点。

如果只需要读取某一类节点，流式循环可以一直复用同一个 decoder；如果需要跳过不关注的完整节点，应该在确认其开始元素后调用 Skip，并且不要再对同一元素调用 DecodeElement。

结语：把边界交给解码器，把选择留给循环

xml.Decoder 负责沿输入流前进，外层循环负责决定“哪个节点值得处理”，DecodeElement 则负责从当前 StartElement 开始完成这一棵局部 XML 子树的结构化读取。这样既不需要一次性加载整份文档，也不必手写嵌套深度管理。

DecodeElement 能读取嵌套结构体吗？

可以。只要目标结构体的字段可导出，XML 标签和嵌套路径表达正确，当前元素下面的子节点会按 Unmarshal 规则写入结构体。

调用 DecodeElement 后还要手动读取 EndElement 吗？

通常不需要。它会处理当前元素对应的内容和结束边界，返回后外层循环继续读取后面的 token。

什么时候应该使用 Skip？

当你已经确认某个完整节点不需要解析，只想跳过它及其嵌套内容时使用 Skip。需要保留节点数据时不要先 Skip。