Adding XMLAdapter causes NullPointerException in JAXBContext.newInstance method

Question

I'm in the process of learning JAXB and wanted to try out some adapters. When I added one to my very simple class it caused the JAXBContext.newInstance() call to throw a NullPointerException. Note that the adapter isn't strictly necessary. If I comment out the @XmlJavaTypeAdapter(MapTypeAdaptor.class) annotation the code works. But that doesn't help me learn how to use adapters... Adding MapType.class and MapTypeEntry.class to JAXBContext.getInstance() didn't fix the problem either.

I would really appreciate any advice on what I'm doing wrong. Thanks!

Here's the Java object I'm marshaling:

import java.util.List;
import java.util.Map;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import com.s5a.api.models.jaxb.MapTypeAdaptor;

@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement
public class TestCollections {

@XmlJavaTypeAdapter(MapTypeAdaptor.class) // <---Adding this line causes the error
private Map<String, Object> oneColor;
public Map<String, Object> getColor() {
    return oneColor;
}
public void setColor(Map<String, Object> oneColor) {
    this.oneColor = oneColor;
}

public List<String> getListOfColors() {
    return listOfColors;
}

public void setListOfColors(List<String> listOfColors) {
    this.listOfColors = listOfColors;
}

private List<String> listOfColors;


}

Here's the adapter:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import javax.xml.bind.annotation.adapters.XmlAdapter;

public class MapTypeAdaptor extends XmlAdapter<MapType, Map<String, Object>> {

@Override
public MapType marshal(Map<String, Object> map) throws Exception {
    ArrayList<MapEntryType> entries = new ArrayList<MapEntryType>();
    MapType mapType = new MapType();
    if (map != null && map.entrySet() != null){
        for (Entry<String, Object> entry : map.entrySet()) {
            MapEntryType mapEntryType = new MapEntryType();
            if (entry != null){
                mapEntryType.setKey(entry.getKey());
                mapEntryType.setValue(entry.getValue());
            }
            entries.add(mapEntryType);
        }
        mapType.setEntries(entries);
    }
    return mapType;
}

@Override
public Map<String, Object> unmarshal(MapType map) throws Exception {
    HashMap<String, Object> hashMap = new HashMap<String, Object>();
    if (map != null){
        for (MapEntryType entryType : map.getEntries()) {
            if (entryType != null){
                hashMap.put(entryType.getKey(), entryType.getValue());
            }
        }
    }
    return hashMap;
}
}

Here's the MapType class:

import java.util.ArrayList;
import java.util.List;

public class MapType {

private List<MapEntryType> mapEntries = new ArrayList<MapEntryType>();

public List<MapEntryType> getEntries() {
    return mapEntries;
}

public void setEntries(List<MapEntryType> mapEntries) {
    this.mapEntries = mapEntries;
}
}

And here's the MapEntryType class:

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlValue;

@XmlAccessorType(XmlAccessType.FIELD)
public class MapEntryType {

@XmlAttribute
private String key;
@XmlValue
private Object value;

public String getKey() {
    return key;
}

public void setKey(String key) {
    this.key = key;
}

public Object getValue() {
    return value;
}

public void setValue(Object value) {
    this.value = value;
}
}

Finally, my unit test:

@Test
    public void shouldReturnXMLRepresentation() throws Exception {

    TestCollections test = new TestCollections();
    HashMap<String, Object> color1 = new HashMap<String, Object>();
    color1.put("blue", new Integer(50));
    HashMap<String, Object> color2 = new HashMap<String, Object>();
    color2.put("red", "red is the 2nd color");
    ArrayList<Map<String, Object>> colors = new ArrayList<Map<String, Object>>();
    colors.add(color1);
    colors.add(color2);
    test.setColor(color1);

    ArrayList<String> listofstrings = new ArrayList<String>();
    listofstrings.add("foo");
    listofstrings.add("bar");
    test.setListOfColors(listofstrings);

    String xmlRepresentaion = genXML(test); 
    assertTrue(xmlRepresentaion != null);
    assertTrue(xmlRepresentaion.length() > 0);
}

private String genXML(Object object) throws Exception{
StringWriter writer = new StringWriter();   
try {
            /* I tried the following, but it also throw an NPE
            JAXBContext jc = JAXBContext.newInstance(TestCollections.class, MapType.class, MapTypeEntry.class);
            */
    JAXBContext jc = JAXBContext.newInstance(TestCollections.class); //<-- NPE
    Marshaller marshaller = jc.createMarshaller();
    marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
    marshaller.marshal(object, writer);
}catch (Exception e){
    System.out.println("Error marshalling: " + e.getMessage());
    e.printStackTrace(System.out); 
    throw e;
}
System.out.println(writer.toString());
    return writer.toString();
}

Answer 1

If you need to store Object values and are willing to accept a slightly different XML output, you can change MapEntryType from:

@XmlAttribute
private String key;
@XmlValue
private Object value;

to:

@XmlElement
private String key;
@XmlElement
private Object value;

This will produce output like:

<entry>
  <key>someKey</key>
  <value xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xs="http://www.w3.org/2001/XMLSchema" xsi:type="xs:string">someValue</value>
</entry>

instead of:

<entry key="someKey">someValue</entry>

Alternatively, if you can change your map from Map<String, Object> to Map<String, String> , then your existing classes should work.