JAXB反序列化树形结构

Question

我有一个XML输入，它本质上是一棵树形结构。目标是将该代码（反）编组为Java类。

<config>

<key-value-pair>
   <key>Key1</key>
   <value>Value1</value>
</key-value-pair>

<key-value-pair>
   <key>Key2</key>
   <value>
      <key-value-pair>
         <key>Subkey2</key>
         <value>Value999</value>
      </key-value-pair>
   </value>
</key-value-pair>

</config>

该XML文件包含了典型的键值对。每个值可以包含另一个键值对、键值对列表或仅一个字符串值。

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
static class KeyValuePair {

    @XmlElement(name="key")
    private String key;

    @XmlElement(name="value")
    private String value;   // here I don't know how to reflect
                            // the choice of String or another
                            // list of KeyValuePair objects
    @XmlElement(name="value")
    private List<KeyValuePair> valuePairs;

    // getters/setters here
}

然后我有另一个包装类。

@XmlRootElement(name="config")
@XmlAccessorType(XmlAccessType.FIELD)
static class Structure {

    @XmlElement(name="key-value-pair")
    private List<KeyValuePair> keyValuePair;

    // getters/setters
 }

这里是我正在尝试使用的（非）编组逻辑。

 Unmarshaller jaxbUnmarshaller = jc.createUnmarshaller();
 StringReader reader = new StringReader(input);
 Structure struct = (Structure) jaxbUnmarshaller.unmarshal(reader);
 // struct doesn't get the data correctly ...

这是我目前得到的。它不像我所想的那样工作，但我希望我已经清楚地表达了最终目标应该是什么样子。

我想把开始时的XML放到Structure类的实例中。

- Albrecht

---

欢迎来到Stack Overflow！这是一个很好、写得不错的问题，但请不要在问题中包含“谢谢！”等无关紧要的短语。把这个网站看作更接近于维基百科而不是论坛。 - durron597

不知道JAXB是什么样子的，但我认为你必须将<value>设置为mixed。不幸的是，这会同时允许文本和元素，你需要在Java代码中进行验证。请参见此处以了解有关XML Schema的一些讨论。 - Andreas

感谢大家的建议。我更希望得到一个完整的可行解决方案。如果我找到了，我会编辑这篇文章。 - Albrecht

Answer 1

你可能已经想到了这一点... 如果您从模式层面开始对其进行建模，就像这样;

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="key-value-pair">
    <xs:sequence>
     <xs:element name="key" type="xs:string"/>
     <xs:element name="value">
        <xs:complexType mixed="true">
            <xs:choice>
                <xs:element name="key-value-pair" type="key-value-pair" minOccurs="0"/>
            </xs:choice>
        </xs:complexType>
     </xs:element>
    </xs:sequence>
  </xs:complexType>
  <xs:element name="config">
    <xs:complexType>
        <xs:sequence>
            <xs:element name="key-value-pair" type="key-value-pair" minOccurs="1" maxOccurs="unbounded"/>
        </xs:sequence>  
    </xs:complexType>
  </xs:element>
</xs:schema>

然后使用XJC Ant任务或以编程方式调用或其他工具来生成最终得到的JAXB类。

package uk.co.his.test.model;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementRef;
import javax.xml.bind.annotation.XmlMixed;
import javax.xml.bind.annotation.XmlType;


/**
 * <p>Java class for key-value-pair complex type.
 * 
 * <p>The following schema fragment specifies the expected content contained within this class.
 * 
 * <pre>
 * &lt;complexType name="key-value-pair"&gt;
 *   &lt;complexContent&gt;
 *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType"&gt;
 *       &lt;sequence&gt;
 *         &lt;element name="key" type="{http://www.w3.org/2001/XMLSchema}string"/&gt;
 *         &lt;element name="value"&gt;
 *           &lt;complexType&gt;
 *             &lt;complexContent&gt;
 *               &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType"&gt;
 *                 &lt;choice&gt;
 *                   &lt;element name="key-value-pair" type="{}key-value-pair" minOccurs="0"/&gt;
 *                 &lt;/choice&gt;
 *               &lt;/restriction&gt;
 *             &lt;/complexContent&gt;
 *           &lt;/complexType&gt;
 *         &lt;/element&gt;
 *       &lt;/sequence&gt;
 *     &lt;/restriction&gt;
 *   &lt;/complexContent&gt;
 * &lt;/complexType&gt;
 * </pre>
 * 
 * 
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "key-value-pair", propOrder = {
    "key",
    "value"
})
public class KeyValuePair {

    @XmlElement(required = true)
    protected String key;
    @XmlElement(required = true)
    protected KeyValuePair.Value value;

    /**
     * Gets the value of the key property.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getKey() {
        return key;
    }

    /**
     * Sets the value of the key property.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setKey(String value) {
        this.key = value;
    }

    /**
     * Gets the value of the value property.
     * 
     * @return
     *     possible object is
     *     {@link KeyValuePair.Value }
     *     
     */
    public KeyValuePair.Value getValue() {
        return value;
    }

    /**
     * Sets the value of the value property.
     * 
     * @param value
     *     allowed object is
     *     {@link KeyValuePair.Value }
     *     
     */
    public void setValue(KeyValuePair.Value value) {
        this.value = value;
    }


    /**
     * <p>Java class for anonymous complex type.
     * 
     * <p>The following schema fragment specifies the expected content contained within this class.
     * 
     * <pre>
     * &lt;complexType&gt;
     *   &lt;complexContent&gt;
     *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType"&gt;
     *       &lt;choice&gt;
     *         &lt;element name="key-value-pair" type="{}key-value-pair" minOccurs="0"/&gt;
     *       &lt;/choice&gt;
     *     &lt;/restriction&gt;
     *   &lt;/complexContent&gt;
     * &lt;/complexType&gt;
     * </pre>
     * 
     * 
     */
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlType(name = "", propOrder = {
        "content"
    })
    public static class Value {
        @XmlElementRef(name = "key-value-pair", type = JAXBElement.class, required = false)
        @XmlMixed
        protected List<Serializable> content;

        /**
         * Gets the value of the content property.
         * 
         * <p>
         * This accessor method returns a reference to the live list,
         * not a snapshot. Therefore any modification you make to the
         * returned list will be present inside the JAXB object.
         * This is why there is not a <CODE>set</CODE> method for the content property.
         * 
         * <p>
         * For example, to add a new item, do as follows:
         * <pre>
         *    getContent().add(newItem);
         * </pre>
         * 
         * 
         * <p>
         * Objects of the following type(s) are allowed in the list
         * {@link String }
         * {@link JAXBElement }{@code <}{@link KeyValuePair }{@code >}
         * 
         * 
         */
        public List<Serializable> getContent() {
            if (content == null) {
                content = new ArrayList<Serializable>();
            }
            return this.content;
        }

    }

}

加上一个ObjectFactory和一个Config类（本质上是您的Structure类）。 ObjectFactory为我们提供了一些“糖”，以帮助处理可怕的JAXBElement舞蹈。

正如Andreas所说，这仍然允许String和嵌套的KeyValuePair。然后，您将不得不使用验证器包装Config类，以检查是否发生了这种情况；例如;

package uk.co.his.test;

import java.io.Serializable;
import java.util.List;

import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;

import uk.co.his.test.model.Config;
import uk.co.his.test.model.KeyValuePair;

public class Validate {


    public void validate(Config c) throws JAXBException
    {
        for(KeyValuePair kvp: c.getKeyValuePair())
        {
            validate(kvp);  
        }
    }

    public void validate(KeyValuePair kv) throws JAXBException
    {
        List<Serializable> mixed = kv.getValue().getContent();
        boolean nonWhitespaceStringFound = false;
        boolean kvpFound = false;
        for(Serializable c: mixed)
        {
            if(c instanceof String)
            {
                String s  = (String) c;
                if(s.trim().length()>0) {
                    nonWhitespaceStringFound = true;
                }
            }
            else
            {
                @SuppressWarnings("unchecked")
                JAXBElement<KeyValuePair> t = (JAXBElement<KeyValuePair>) c;
                KeyValuePair child = t.getValue();
                kvpFound = true;
                validate(child);
            }
            if(kvpFound && nonWhitespaceStringFound) {
                throw new JAXBException("KeyValuePair "+kv.getKey()+" value element contained String data and nested KeyValuePair(s)");
            }
        }
    }
}

要创建配置，您需要执行JAXBElement舞蹈;

private static final File Test1Out = new File("files/test1.xml");
@Test
public void test1() throws JAXBException
{
    ObjectFactory of = new ObjectFactory();
    Config c = new Config();
    c.getKeyValuePair().add(createKVPair(of, 2, 2, "a", "one"));
    c.getKeyValuePair().add(createKVPair(of, 2, 1, "b", "two"));
    c.getKeyValuePair().add(createKVPair(of, 0, 0, "c", "three"));
    JAXBContext jbc = JAXBContext.newInstance("uk.co.his.test.model");
    Marshaller m = jbc.createMarshaller();
    m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
    m.marshal(c, Test1Out);

    Unmarshaller u = jbc.createUnmarshaller();
    Config c2 = (Config) u.unmarshal(Test1Out);
    Assert.assertTrue("Round trip produces different things", c2.getKeyValuePair().size() ==3);
}

private KeyValuePair createKVPair(ObjectFactory of, int depth, int length, String initialKey, String value) {
    KeyValuePair kv = new KeyValuePair();
    kv.setKey(initialKey);
    Value v = new Value();
    kv.setValue(v);
    if(depth==0)
    {
        v.getContent().add(value);
    }
    else 
    {
        int newdepth = --depth;
        for(int i = 0; i < length; i++)
        {
            v.getContent().add(of.createKeyValuePairValueKeyValuePair(createKVPair(of, newdepth, length, initialKey+depth, value+i)));
        }
    }
    return kv;
}

好的，这是一个开始...

- JFK