Question

I’m struggling with the few problems marshal/unmarshall JSon and it looks i will never get it work 🙁

Look the first issue: I have a class Response that contains few fields: String error, String error_code and Object response. Class responsible to fill all the data to response, fill the error fields if needed and send it back to the client for further analisys.

“Object response” can be any of type (why Object? because it didn’t worked with interfaces and that would be the second part of the question)

code snippet:

   @XmlRootElement
    @XmlAccessorType(XmlAccessType.FIELD)
    public class Response
    {
        public static final String ERROR_FIELD_NAME = "error";
        public static final String ERROR_CODE_FIELD_NAME = "error_code";
        public static final String RESPONSE_FIELD_NAME = "response";

        @XmlElement(name = Response.ERROR_CODE_FIELD_NAME)
        private String errorCode;

        @XmlElement(name = Response.ERROR_FIELD_NAME)
        private String errorMessage;

        @XmlElementRefs(
            {@XmlElementRef(type = AClassResponse.class),
        @XmlElementRef(type = BClassResponse.class)})
        private Object entity;

and etc…

import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.adapters.XmlAdapter;


//@XmlRootElement(name = Response.RESPONSE_FIELD_NAME)
//@XmlJavaTypeAdapter(AClassResponse.Adapter.class)
@XmlRootElement
public class AClassResponse
{
    private TargetObject target;


    public TargetObject getTarget()
    {
        return target;
    }


    public void setTarget(TargetObject target)
    {
        this.target = target;
    }
}

JSON 1 (for XmlElementRef AClassResponse.class ):
    { 
      "error" : "",
      "error_code" : "",
      **"aClassResponse" :** 
         { "target" : 
            { "accountId" : "5bd0812b",
              "id" : "6ccb6ae1-30c3-4aa0-8d1e-6ed61b6bb217",
              "isCaseSensitive" : "false",
              "maxNumberOfConnections" : "0",
              "name" : "targetName",
              "pathDelimiter" : "/",
              "type" : "SMB"
            } 
         }
    }

JSON 1 (for XmlElementRef BClassResponse.class):
   { 
      "error" : "",
      "error_code" : "",
      **"bClassResponse" :** 
         { "target" : 
            { "accountId" : "5bd0812b",
              "id" : "6ccb6ae1-30c3-4aa0-8d1e-6ed61b6bb217",
              "isCaseSensitive" : "false",
              "maxNumberOfConnections" : "0",
              "name" : "targetName",
              "pathDelimiter" : "/",
              "type" : "SMB"
            } 
         }
    }

Now the problem:

Look on JSon above, “aClassResponse” : and “bClassResponse” : are always dynamic (means the name is derived from the class name) – an this is not what I need.

My goal is to give this name a persistent name “response”, so any remote clients will aware about this and rely on this name.

I know, to fix that I can annotate AClassResponse.class with @XmlRootElement(name = “response”), and it does work untill you have more than one @XmlElementRef defined.

If two or more, this cause an issue with marshaling/unnmarshaling, and JAXB doesn’t know what class to bind it should bind to the entity field, since it rely on name as well (name = “response”)

@XmlElementRefs(
        {@XmlElementRef(type = AClassResponse.class),
        @XmlElementRef(type = BClassResponse.class)})
        private Object entity;

it treat it like this:

@XmlElementRefs(
            {@XmlElementRef(name = "response", type = AClassResponse.class),
            @XmlElementRef(name = "response", type = BClassResponse.class)})
            private Object entity;

Assume this a correct behaviour and there is nothing i can do to keep the the same (name = “response”) for any of object types.

OK, i tried to workaround it by introducing interface instead of Object type + @XmlJavaTypeAdapter(AClassResponse.Adapter.class) for each of implementation – however it didn’t worked either, throwing exception that interfaces are not supported and etc…

This article seems can shed some light on this, http://jaxb.java.net/guide/Mapping_interfaces.html

but it fails too, saying that it can’t instantiate abstract class abstract class AbstractFooImpl

@XmlJavaTypeAdapter(AbstractFooImpl.Adapter.class)
interface IFoo {
  ...
}
**abstract class AbstractFooImpl implements IFoo {**
  ...

  static class Adapter extends XmlAdapter<AbstractFooImpl,IFoo> {
    IFoo unmarshal(AbstractFooImpl v) { return v; }
    AbstractFooImpl marshal(IFoo v) { return (AbstractFooImpl)v; }
  }
}

class SomeFooImpl extends AbstractFooImpl {
  @XmlAttribute String name;
  ...
}

class AnotherFooImpl extends AbstractFooImpl {
  @XmlAttribute int id;
  ...
}

class Somewhere {
  public IFoo lhs;
  public IFoo rhs;
}

Any advices on how i can workaround this? Please help..

thank you.

Answer 1

JAXB doesn’t do interfaces. The solution is either generics or abstract classes (annotated with @XmlTransient to make JAXB ignore the base class and @XmlSeeAlso to make it use specific implementations instead). That solves the Java part, but you still need to fix the XSD part of the equation (remember that JAXB only sees an XML version of your JSON through Jersey).

For that purpose you can use the @XmlElementRef and @XmlElementRefs annotations on your field so that the XSD will map to a choice of the specific implementations.

@XmlTransient // JAXB doesn't like abstract types, so do not map this type name
// XmlSeeAlso only required if BaseImpl/BaseImpl2 are not otherwise auto-discovered by JAXB
@XmlSeeAlso({BaseImpl.class, BaseImpl2.class })
public abstract class Base {
  @XmlElement(name='still-works')
  public String thisFieldWillStillBeMappedByJAXB;
}

@XmlRootElement("base-impl")
public class BaseImpl {}

@XmlRootElement("alternative")
public class BaseImpl2 {}

public class Complex<E extends Base> {
   @XmlElementRefs({
     @XmlElementRef(type=BaseImpl.class), 
     @XmlElementRef(type=BaseImpl2.class)
   })
   public E impl; // will be an instance of either "base-impl" or "alternative"
}