JAXB Element With Specific Type But Unknown Names

Question

I have a root Xml document (name = "Entity") that contains one known Xml element (name = "Header") and another Xml element of unknown name but it is known to have an inner XmlElement(name="label")

Here are possible Xmls:

<Entity>
   <Header>this is a header</Header>
   <a>
     <label>this is element A</label>
     <otherElements/>
   </a>
</Entity>

<Entity>
   <Header>this is a different header</Header>
   <b>
     <label>this is some other element of name b</label>
     <others/>
   </b>
</Entity>

Here are my JAXB annotated classes:

@XmlRootElement(name = "Entity")
@XmlAccessorType(XmlAccessType.NONE)
public class Entity {
    @XmlElement(name = "Header")
    private Header header;

    @XmlElements( {
       @XmlElement(name = "a", type=LabelledElement.A.class), 
       @XmlElement(name = "b", type=LabelledElement.B.class)
    } )
    private LabelledElement labelledElement;

    // constructors, getters, setters...
}

@XmlAccessorType(XmlAccessType.NONE)
public abstract class LabelledElement {
     @XmlElement
     private String label;
     @XmlAnyElement
     private List<Element> otherElements;

     public static class A extends LabelledElement {}
     public static class B extends LabelledElement {}
}

This was working great! But then I noticed that it isn't only <a> and <b>

It could be <c>, <asd> and even <anything>...

So listing the XmlElement(name = "xyz", type = LabelledElement.xyz.class) is obviously not the right solution.

All I care about is Entity#getLabelledElement()#getLabel() no matter what the LabelledElement name is.

Is this even possible with JAXB?

Answer 1

With EclipseLink JAXB Implementation (MOXy), this should work :

@XmlRootElement(name = "Entity")
@XmlSeeAlso({LabelledElement.class}) //Might not be necessary
@XmlAccessorType(XmlAccessType.NONE)
public class Entity {
    @XmlElement(name = "Header")
    private Header header;

    @XmlPath("child::*[position() = 2]")
    @XmlJavaTypeAdapter(MapAdapter.class)
    private Map<String,LabelledElement> labelledElementMap;


    public LabelledElement getLabelledElement(){
         return labelledElementMap.values().get(0);
    }
    // constructors, getters, setters...
}

The MapAdapter class :

public class MapAdapter extends XmlAdapter<MapAdapter.AdaptedMap, Map<String, LabelledElement>> {

    public static class AdaptedMap {

        @XmlVariableNode("key")
        List<LabbeledElement> entries = new ArrayList<LabbeledElement>();

    }

    public static class AdaptedEntry {

        @XmlTransient
        public String key;

        @XmlElement
        public LabelledElement value;

    }

    @Override
    public AdaptedMap marshal(Map<String, LabelledElement> map) throws Exception {
        AdaptedMap adaptedMap = new AdaptedMap();
        for(Entry<String, LabelledElement> entry : map.entrySet()) {
            AdaptedEntry adaptedEntry = new AdaptedEntry();
            adaptedEntry.key = entry.getKey();
            adaptedEntry.value = entry.getValue();
            adaptedMap.entries.add(adaptedEntry);
        }
        return adaptedMap;
    }

    @Override
    public Map<String, LabelledElement> unmarshal(AdaptedMap adaptedMap) throws Exception {
        List<AdaptedEntry> adaptedEntries = adaptedMap.entries;
        Map<String, LabelledElement> map = new HashMap<String, LabelledElement>();
        for(AdaptedEntry adaptedEntry : adaptedEntries) {
            map.put(adaptedEntry.key, adaptedEntry.value);
        }
        return map;
    }

}

For reference, my solution is inspired by this link.

Answer 2

Apparently it's possible with EclipseLink JAXB (MOXy) implementation, which allows you annotate an interface variable providing a Factory class and method to be used when binding XML to Java, see this answer.

(edited to provide an example of this approach) For instance, you instead of having an abstract class LabelledElement, have an interface LabelledElement:

public interface LabelledElement {
    String getLabel();
}

and then have classes A and B implement it like this:

import javax.xml.bind.annotation.XmlElement;

public class A implements LabelledElement{

    private String label;

    @Override
    @XmlElement(name="label")
    public String getLabel() {
        return label;
    }
}

and Entity class annotated like this:

@XmlRootElement(name = "Entity")
@XmlAccessorType(XmlAccessType.NONE)
public class Entity {
    @XmlElement(name = "Header")
    private Header header;

    @XmlRootElement
    @XmlType(
    factoryClass=Factory.class, 
    factoryMethod="createLabelledElement")
    private LabelledElement labelledElement;

    // constructors, getters, setters...
}

Then, as the answer I linked to suggests, you need a Factory class like:

import java.lang.reflect.*;
import java.util.*;

public class Factory {

    public A createA() {
        return createInstance(A.class);
    }

    public B createB() {
        return createInstance(B.class);;
    }

    private <T> T createInstance(Class<T> anInterface) {
        return (T) Proxy.newProxyInstance(anInterface.getClassLoader(), new Class[] {anInterface}, new InterfaceInvocationHandler());
    }

    private static class InterfaceInvocationHandler implements InvocationHandler {

        private Map<String, Object> values = new HashMap<String, Object>();

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            String methodName = method.getName();
            if(methodName.startsWith("get")) {
                return values.get(methodName.substring(3));
            } else {
                values.put(methodName.substring(3), args[0]);
                return null;
            }
        }

    }
}