在没有POJO类和使用linkedHashmaps的情况下实现JAXB

Question

我正在尝试使用JAXB实现将类对象转换为XML，反之亦然。我通过观察一个教程来实现这一点。

我的XML看起来像这个

<Alphabet>
    <a>Apple</a>
    <b>Ball</b>
    <c>Cat</c> 
    <d>Dog</d>
    <e>Elephant</e>
    <f>Fox</f>
</Alphabet>

我写了以下课程

import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Alph {
    @XmlElement
    private LinkedHashMap<String, String> cLinkedHashMap = new 
            LinkedHashMap<String, String>();
    protected void put(String theKey, String theValue) {
        cLinkedHashMap.put(theKey, theValue);   
    }
    protected String get(String theKey) {
        return (String) cLinkedHashMap.get(theKey);
    }
    protected Set<Entry<String,String>> getCEntrySet() {
        return cLinkedHashMap.entrySet();
    }
    protected LinkedHashMap<String, String> getCLinkedHashMap() {
        return cLinkedHashMap;
    }
    public String toCXML() throws XMLHandlingException {
        return null;
    }
}
@XmlRootElement
public class Alphabet extends Alph {
    public static Alphabet getInstance(String theAlphabetXML) throws 
    XMLHandlingException {
        return XMLUtils.parseAlphabetXML(theAlphabetXML);
    }
    public String toCXML() throws XMLHandlingException {
        return XMLUtils.getAlphabetXML(this);
    }
}

我创建了以下XMLUtil方法来编组和取消编组

public static String getAlphabetXML(Alph theAlphabet) throws XMLHandlingException {
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    Writer writer = null;
    try {
        writer = new OutputStreamWriter(byteArrayOutputStream, "UTF-8");
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    try {
        writer.write("<?xml version="1.0" encoding="UTF-8" ?>" );
    } catch (IOException e) {
        e.printStackTrace();
    }
    try {
        JAXBContext JContext = JAXBContext.newInstance(Alphabet.class); 
        Marshaller JMarshaller = JContext.createMarshaller();
        JMarshaller.marshal(theAlphabet, writer);
    } catch (Throwable e) {
        e.printStackTrace();
    }
    String theAlphabetXML = byteArrayOutputStream.toString();
    return theAlphabetXML;
}
public static Alphabet parseAlphabetXML(String theAlphabetXML) throws 
XMLHandlingException {
    if(null == theAlphabetXML) {
        return null;
    }
    try {
        InputStream IPStream = new ByteArrayInputStream(theALphabetXML.getBytes());
        JAXBContext JContext = JAXBContext.newInstance(Alphabet.class);
        Unmarshaller JUnmarshaller = JContext.createUnmarshaller();
        Alphabet alphabet = (Alphabet) JUnmarshaller.unmarshal(IPStream);
        return alphabet;
    } catch(Throwable t) {
        t.printStackTrace();
    }
}

我的问题是，当我试图整理或取消整理时，我会遇到以下错误"javax.xml.bind.UnmarshalException：意外元素（a:"，local:"Alphabet"）。预期元素为<｛｝Alphabet>"

我错过什么了吗？感谢您的帮助。

感谢

---

更新

---

我紧随其后http://blog.bdoughan.com/2013/06/moxys-xmlvariablenode-using-maps-key-as.html并更新了我的代码如下

请求和响应XML

<AlphabetReq>
    <a>Apple</a>
    <b>Ball</b>
    <c>Cat</c> 
    <d>Dog</d>
    <e>Elephant</e>
    <f>Fox</f>
</AlphabetReq>
<AlphabetResp>
    <a>Apple</a>
    <b>Ball</b>
    <c>Cat</c> 
    <d>Dog</d>
    <e>Elephant</e>
    <f>Fox</f>
</AlphabetResp>

AlphabetReq和AlphabetResp类

import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import org.eclipse.persistence.oxm.annotations.XmlPath;
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Alph {
@XmlPath(".")
@XmlJavaTypeAdapter(AlphAdapter.class)
private LinkedHashMap<String, String> cLinkedHashMap = new 
        LinkedHashMap<String, String>();
@XmlPath(".")
@XmlJavaTypeAdapter(AlphAdapter.class)
private LinkedHashMap<String, String> gLinkedHashMap = new 
        LinkedHashMap<String, String>();
protected void put(String theKey, String theValue) {
    cLinkedHashMap.put(theKey, theValue);   
    gLinkedHashMap.put(theKey, theValue);
}
protected String get(String theKey) {
    return (String) cLinkedHashMap.get(theKey);
}
protected Set<Entry<String,String>> getCEntrySet() {
    return cLinkedHashMap.entrySet();
}
protected Set<Entry<String,String>> getGEntrySet() {
    return gLinkedHashMap.entrySet();
}
protected LinkedHashMap<String, String> getCLinkedHashMap() {
    return cLinkedHashMap;
}
protected LinkedHashMap<String, String> getGLinkedHashMap() {
    return gLinkedHashMap;
}
public String toCXML() throws XMLHandlingException {
    return null;
}
public String toGXML() throws XMLHandlingException {
    return null;
}
}
@XmlRootElement(name="AlphReq")
@XmlDiscriminatorValue("AlphabetReq")
@XmlAccessorType(XmlAccessType.FIELD)
public class AlphabetReq extends Alph {
public static AlphabetReq getInstance(String theAlphabetReqXML) throws 
XMLHandlingException {
    return XMLUtils.parseAlphabetReqXML(theAlphabetReqXML);
}
public String toCXML() throws XMLHandlingException {
    return XMLUtils.getAlphabetReqXML(this);
}
}
@XmlRootElement(name="AlphResp")
@XmlDiscriminatorValue("AlphabetResp")
@XmlAccessorType(XmlAccessType.FIELD)
public class AlphabetResp extends Alph {
public static AlphabetResp getInstance(String theAlphabetRespXML) throws 
XMLHandlingException {
    return XMLUtils.parseAlphabetRespXML(theAlphabetRespXML);
}
public String toCXML() throws XMLHandlingException {
    return XMLUtils.getAlphabetRespXML(this);
}
}

我创建了以下XMLUtil方法来编组和取消编组

public static String getAlphabetReqXML(Alph theAlphabet) throws XMLHandlingException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Writer writer = null;
try {
    writer = new OutputStreamWriter(byteArrayOutputStream, "UTF-8");
} catch (UnsupportedEncodingException e) {
    e.printStackTrace();
}
try {
    writer.write("<?xml version="1.0" encoding="UTF-8" ?>" );
} catch (IOException e) {
    e.printStackTrace();
}
try {
    JAXBContext JContext = JAXBContext.newInstance(AlphabetReq.class); 
    Marshaller JMarshaller = JContext.createMarshaller();
    JMarshaller.marshal(theAlphabet, writer);
} catch (Throwable e) {
    e.printStackTrace();
}
String theAlphabetReqXML = byteArrayOutputStream.toString();
return theAlphabetReqXML;
}
public static AlphabetReq parseAlphabetReqXML(String theAlphabetReqXML) throws 
XMLHandlingException {
if(null == theAlphabetReqXML) {
    return null;
}
try {
    InputStream IPStream = new ByteArrayInputStream(theAlphabetReqXML.getBytes());
    JAXBContext JContext = JAXBContext.newInstance(AlphabetReq.class);
    Unmarshaller JUnmarshaller = JContext.createUnmarshaller();
    AlphabetReq alphabetreq = (AlphabetReq) JUnmarshaller.unmarshal(IPStream);
    return alphabetreq;
} catch(Throwable t) {
    t.printStackTrace();
}
}
public static String getAlphabetRespXML(Alph theAlphabet) throws XMLHandlingException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Writer writer = null;
try {
    writer = new OutputStreamWriter(byteArrayOutputStream, "UTF-8");
} catch (UnsupportedEncodingException e) {
    e.printStackTrace();
}
try {
    writer.write("<?xml version="1.0" encoding="UTF-8" ?>" );
} catch (IOException e) {
    e.printStackTrace();
}
try {
    JAXBContext JContext = JAXBContext.newInstance(AlphabetResp.class); 
    Marshaller JMarshaller = JContext.createMarshaller();
    JMarshaller.marshal(theAlphabet, writer);
} catch (Throwable e) {
    e.printStackTrace();
}
String theAlphabetRespXML = byteArrayOutputStream.toString();
return theAlphabetRespXML;
}
public static AlphabetResp parseAlphabetReqXML(String theAlphabetRespXML) throws 
XMLHandlingException {
if(null == theAlphabetRespXML) {
    return null;
}
try {
    InputStream IPStream = new ByteArrayInputStream(theAlphabetRespXML.getBytes());
    JAXBContext JContext = JAXBContext.newInstance(AlphabetResp.class);
    Unmarshaller JUnmarshaller = JContext.createUnmarshaller();
    AlphabetResp alphabetresp = (AlphabetResp) JUnmarshaller.unmarshal(IPStream);
    return alphabetresp;
} catch(Throwable t) {
    t.printStackTrace();
}
}

并引入了适配器类

import java.util.*;
import java.util.Map.Entry;
import javax.xml.bind.annotation.*;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import org.eclipse.persistence.oxm.annotations.XmlVariableNode;
public class AlphAdapter extends XmlAdapter<AlphAdapter.AdaptedMap, LinkedHashMap<String, String>>{
public static class AdaptedMap {
    @XmlVariableNode("key")
    List<AdaptedEntry> entries = new ArrayList<AdaptedEntry>();  
}
public static class AdaptedEntry {  
    @XmlTransient
    public String key;
    @XmlValue
    public String value;
}
@Override
public AdaptedMap marshal(LinkedHashMap<String, String> map) throws Exception {
    AdaptedMap adaptedMap = new AdaptedMap();
    for(Entry<String, String> entry : map.entrySet()) {
        AdaptedEntry adaptedEntry = new AdaptedEntry();
        adaptedEntry.key = entry.getKey();
        adaptedEntry.value = entry.getValue();
        adaptedMap.entries.add(adaptedEntry);
    }
    return adaptedMap;
}
@Override
public LinkedHashMap<String, String> unmarshal(AdaptedMap adaptedMap) throws Exception {
    List<AdaptedEntry> adaptedEntries = adaptedMap.entries;
    LinkedHashMap<String, String> map = new LinkedHashMap<String, String>(adaptedEntries.size());
    for(AdaptedEntry adaptedEntry : adaptedMap.entries) {
        map.put(adaptedEntry.key, adaptedEntry.value);
    }
    return map;
}
}

当我运行这个时，我不会在自适应映射中获得任何值。它有键，但值为null例如：

• 键：A，值：null
• 键：B，值：null
• 键：C，值：null
• 键：D，值：null
• 键：E，值：null
• 键：F，值：null

感谢您的帮助。

感谢

Answer 1

您可以实现以下简单的XML创建（您已经给出）：

@XmlRootElement
public class Alphabet {
    private String a;
    private String b;
    private String c;
    private String d;
    private String e;
    private String f;
    public Alphabet() {
    }
    public Alphabet(String a, String b, String c, String d, String e, String f) {
        super();
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
        this.f = f;
    }
    public String getA() {
        return a;
    }
    public void setA(String a) {
        this.a = a;
    }
    public String getB() {
        return b;
    }
    public void setB(String b) {
        this.b = b;
    }
    public String getC() {
        return c;
    }
    public void setC(String c) {
        this.c = c;
    }
    public String getD() {
        return d;
    }
    public void setD(String d) {
        this.d = d;
    }
    public String getE() {
        return e;
    }
    public void setE(String e) {
        this.e = e;
    }
    public String getF() {
        return f;
    }
    public void setF(String f) {
        this.f = f;
    }
}

这个类用于创建xml文件：

public class AlphabetToXML {
    public static void main(String[] args) {
        Alphabet alpha = new Alphabet("Apple", "Ball", "Cat", "Dog",
                "Elephant", "Fox");
        try {
            String filePath = "PATH_TO_SAVE_YOUR_FILE";
            File file = new File(filePath);
            JAXBContext jaxbContext = JAXBContext.newInstance(Alphabet.class);
            Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
            // output pretty printed
            jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            jaxbMarshaller.marshal(alpha, file);
            jaxbMarshaller.marshal(alpha, System.out);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }
}

这是将XML读取回Java对象：

public class XMLToAplhabet {
    public static void main(String[] args) {
        try {
            String filePath = "XML_FILE_PATH";
            File file = new File(filePath);
            JAXBContext jaxbContext = JAXBContext.newInstance(Alphabet.class);
            Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
            Alphabet aplha = (Alphabet) jaxbUnmarshaller.unmarshal(file);
            System.out.println(aplha);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }
}

我看不到使用LinkedHashMap来创建这样一个简单的XML。

Answer 2

http://java.dzone.com/articles/jaxb-and-javautilmap可能会有所帮助。包含执行同一任务的不同方法。