Question

I’d like to marshall/unmarshall a Map into attributes of an XML element. I’ve seen examples like:

<map>
<entry key="key1">value1</entry>
<entry key="key2">value2</entry>
</map>

What I really want is:

<map key1="value1" key2="value2"/>

Assume with me that there are no complex values and that they can legally be represented as XML attributes. Also, I’m trying to write this generically because the set of keys is not known until runtime.

How would I go about this? I’m familiar with XmlJavaTypeAdapter.

I thought about creating a MyMap that contains a List of entries but this wouldn’t get the output I’d like.

Answer 1

Like I hinted in my comment, this cannot be achieved with JAXB alone. In the JAXB specification (JSR 222) it says:

In all application scenarios, we create a Java object-level binding of the schema.

That means that the scope of the binding is the same as the scope of the schema, which is static. A JAXB binding is not meant to be changed without recompiling the code. There are some exceptions, e.g. for xs:anyAttribute which is discussed in section 6.9 of the specification, but since you didn’t vote for the answer suggesting the use of @XmlAnyAttribute you probably don’t want to live with the limitations – e.g. only have QName keys in your map.

I hope you are convinced that to do what you want with JAXB is a really bad idea, but just for reference below is an example that modifies the document after marshalling to bring it to the structure you want. You can copy and paste it into a single file and compile it with Java 7. The output will look like this:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<mapExample>
  <map France="Paris" Japan="Tokyo"/>
</mapExample>

My code only shows the marshalilng the other direction is equivalent:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

@XmlRootElement
class MapExample {
  @XmlJavaTypeAdapter(MapXmlAdapter.class)
  @XmlElement(name="map")
  private Map<String, String> data = new HashMap<>();

  public static void main(String[] args) throws Exception {
    MapExample example = new MapExample();
    example.data.put("France", "Paris");
    example.data.put("Japan", "Tokyo");

    JAXBContext context = JAXBContext.newInstance(MapExample.class);
    Marshaller marshaller = context.createMarshaller();
    DOMResult result = new DOMResult();
    marshaller.marshal(example, result);

    XPathFactory factory = XPathFactory.newInstance();
    XPath xpath = factory.newXPath();

    Document document = (Document)result.getNode();
    XPathExpression expression = xpath.compile("//map/entry");
    NodeList nodes = (NodeList)expression.evaluate(document, XPathConstants.NODESET);

    expression = xpath.compile("//map");
    Node oldMap = (Node)expression.evaluate(document, XPathConstants.NODE);    
    Element newMap = document.createElement("map");

    for (int index = 0; index < nodes.getLength(); index++) {
      Element element = (Element)nodes.item(index);
      newMap.setAttribute(element.getAttribute("key"), 
          element.getAttribute("value"));
    }

    expression = xpath.compile("//map/..");
    Node parent = (Node)expression.evaluate(document, XPathConstants.NODE);    
    parent.replaceChild(newMap, oldMap);

    TransformerFactory.newInstance().newTransformer().
      transform(new DOMSource(document), new StreamResult(System.out));
  }
}

class MapXmlAdapter extends XmlAdapter<MyMap, Map<String, String>> {
  @Override
  public Map<String, String> unmarshal(MyMap value) throws Exception {
    throw new UnsupportedOperationException();
  }

  @Override
  public MyMap marshal(Map<String, String> value) throws Exception {
    MyMap map = new MyMap();
    map.entries = new ArrayList<MyEntry>();
    for (String key : value.keySet()) {
      MyEntry entry = new MyEntry();
      entry.key = key;
      entry.value = value.get(key);
      map.entries.add(entry);
    }
    return map;
  }
}

class MyMap {
  @XmlElement(name="entry")
  public List<MyEntry> entries;
}

class MyEntry {
  @XmlAttribute
  public String key;

  @XmlAttribute
  public String value;
}