java - 在没有 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：”，本地：“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;
}
}

当我运行它时，我没有在我的adaptedmap 中获得任何值。它有键，但值为空，例如：

键：A，值：空
键：B，值：空
键：C，值：空
键：D，值：空
键：E，值：空
键：F，值：空

任何帮助表示赞赏。

谢谢

score 1 · Accepted Answer

您可以实现这个简单的 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。

score 1 · Accepted Answer

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

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

2 回答 2

Related

Reference