Go反序列化XML到自定义结构体：处理同标签多结构问题

我有一个简化的.owl格式XML示例：

<?xml version="1.0"?>
<rdf:RDF xmlns="http://www.w3.org/2002/07/owl#"
     xml:base="http://www.w3.org/2002/07/owl"
     xmlns:owl="http://www.w3.org/2002/07/owl#"
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:xml="http://www.w3.org/XML/1998/namespace"
     xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
     xmlns:mc="http://my-company/ontologies#">
    <Ontology rdf:about="http://my-company/ontologies"/>

    <Class rdf:about="http://my-company/ontologies#Thing">
        <rdfs:subClassOf rdf:nodeID="genid494"/>
        <rdfs:subClassOf>
            <Restriction>
                <onProperty rdf:resource="http://my-company/ontologies#myProp1"/>
            </Restriction>
        </rdfs:subClassOf>
    </Class>
    <Restriction rdf:nodeID="genid494">
        <onProperty rdf:resource="http://my-company/ontologies#myProp2"/>
    </Restriction>
</rdf:RDF>

问题在于Class的subClassOf子节点既可以是对Restriction的引用（带rdf:nodeID或rdf:resource属性），也可以直接嵌入Restriction节点。

我尝试将该XML反序列化为以下Go结构体：

type RDF struct {
    XMLName  xml.Name `xml:"RDF"`
    XMLNS    string   `xml:"xmlns,attr"`
    Base     string   `xml:"base,attr"`
    OWLNS    string   `xml:"owl,attr"`
    RDFNS    string   `xml:"rdf,attr"`
    XML      string   `xml:"xml,attr"`
    XSD      string   `xml:"xsd,attr"`
    RDFS     string   `xml:"rdfs,attr"`
    MCNS     string   `xml:"mc,attr"`
    Ontology struct {
        About *string `xml:"about,attr"`
    } `xml:"Ontology"`

    Classes      []Class       `xml:"Class,omitempty"`
    Restrictions []Restriction `xml:"Restriction,omitempty"`
}
type Restriction struct {
    OnProperty ResourceData `xml:"onProperty"`
}
type ResourceData struct {
    Resource string `xml:"resource,attr"`
}
type Class struct {
    ClassDefinition []ClassDescriptor `xml:"subClassOf,omitempty"`
}
type ClassDescriptor struct {
    Restriction *RestrictionReference `xml:"restriction"`
}
type RestrictionReference struct {
    inner     *Restriction
    reference *string
}

我的目标是让RestrictionReference既能存储内嵌的Restriction子节点，也能存储引用（后续可添加GetRestriction方法隐藏查找逻辑），但无法正确实现*ClassDescriptor的xml.Unmarshaler接口，当前的实现无法解析子节点：

func (description *ClassDescriptor) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
    // easier case: there is just a reference
    for _, attr := range start.Attr {
        switch attr.Name.Local {
        case "resource":
            cp := attr.Value
            description.Restriction.reference = &cp
        case "nodeID":
            nodeID := attr.Value
            description.Restriction.reference = &nodeID
        default:
            return errors.New("unknown xml attribute:" + attr.Name.Local)
        }
    }
    // temporary? workaround to avoid the "did not consume the entire element" err for the easier case
    if len(start.Attr) == 0 {
        return d.Skip()
    } else {
        // complicated case: there is a child node with the Restriction
        // TODO unmarshal Restriction and set it in the RestrictionReference prop
        var redData Restriction
        // will be empty, but I don't know what to pass here instead
        err := d.DecodeElement(&redData, &start)
        description.Restriction.inner = &redData
        return err
    }
}

我也考虑过在ClassDescriptor中同时声明两种可能性：

type ClassDescriptor struct {
    NodeID      *NodeID      `xml:"nodeID,attr"`
    Restriction *Restriction `xml:"Restriction"` 
}

但这会增加外部处理的复杂度，我仍想了解如何实现能读取子节点的xml.Unmarshaler。

你的思路完全可行，问题出在UnmarshalXML的实现逻辑上——你需要正确遍历元素的子节点，而不是直接用DecodeElement处理原始的start元素。以下是修正后的实现：

首先，确保RestrictionReference初始化（避免空指针），然后在解析时区分两种场景：

import (
    "encoding/xml"
    "errors"
)

// 先修正ClassDescriptor的结构，确保RestrictionReference被初始化
type ClassDescriptor struct {
    Restriction *RestrictionReference
}

func (cd *ClassDescriptor) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
    // 初始化RestrictionReference，避免空指针
    cd.Restriction = &RestrictionReference{}

    // 先检查是否是引用场景（带nodeID或resource属性）
    for _, attr := range start.Attr {
        // 注意要考虑命名空间，因为属性是rdf:nodeID/rdf:resource
        if attr.Name.Space == "http://www.w3.org/1999/02/22-rdf-syntax-ns#" {
            switch attr.Name.Local {
            case "nodeID":
                val := attr.Value
                cd.Restriction.reference = &val
            case "resource":
                val := attr.Value
                cd.Restriction.reference = &val
            }
        }
    }

    // 如果已经找到引用，需要跳过当前元素的所有子节点
    if cd.Restriction.reference != nil {
        return d.Skip()
    }

    // 处理内嵌Restriction的场景：遍历子节点
    var err error
    for {
        var tok xml.Token
        tok, err = d.Token()
        if err != nil {
            return err
        }

        switch t := tok.(type) {
        case xml.StartElement:
            if t.Name.Local == "Restriction" {
                var res Restriction
                if err = d.DecodeElement(&res, &t); err != nil {
                    return err
                }
                cd.Restriction.inner = &res
            } else {
                // 遇到未知子节点，跳过
                if err = d.Skip(); err != nil {
                    return err
                }
            }
        case xml.EndElement:
            // 到达当前元素的结束标签，退出循环
            return nil
        }
    }
}

关键修正点： #

• 初始化引用对象：在UnmarshalXML开头就初始化RestrictionReference，避免后续赋值时出现空指针 panic。
• 处理命名空间：OWL/RDF的属性（如rdf:nodeID）带有命名空间，之前的代码只检查了Local名称，会漏掉这些属性。
• 遍历子节点：通过循环读取xml.Token来处理内嵌的Restriction节点，而不是直接用DecodeElement处理原始的start元素——后者会尝试把整个subClassOf元素解码为Restriction，导致失败。
• 正确结束解析：当遇到xml.EndElement时退出循环，确保消耗完整个subClassOf元素，避免"did not consume the entire element"错误。

补充：RestrictionReference的GetRestriction方法 #

你可以添加如下方法来隐藏查找逻辑：

func (rr *RestrictionReference) GetRestriction(rdf RDF) *Restriction {
    if rr.inner != nil {
        return rr.inner
    }
    if rr.reference == nil {
        return nil
    }
    // 根据reference查找对应的Restriction（nodeID或resource）
    for _, res := range rdf.Restrictions {
        // 这里需要扩展Restriction结构体，添加NodeID字段来存储rdf:nodeID
        // 修正后的Restriction结构体：
        // type Restriction struct {
        //     NodeID      string        `xml:"nodeID,attr"`
        //     OnProperty  ResourceData  `xml:"onProperty"`
        // }
        if res.NodeID == *rr.reference {
            return &res
        }
    }
    return nil
}

注意：需要给Restriction结构体添加NodeID字段，才能存储<Restriction rdf:nodeID="genid494"/>中的节点ID，否则无法通过引用查找对应的限制。

内容的提问来源于stack exchange，提问作者NotX