JAXB generic @XmlValue

Question

The goal is to produce the following XML with JAXB

<foo>
   <bar>string data</bar>
   <bar>binary data</bar>
</foo>

Is there a workaround to allow generic @XmlValue fields (I need to store byte[] and String data)? Below is what I desire:

@XmlRootElement
public class Foo {
    private @XmlElement List<Bar> bars;
}

@XmlRootElement
public class Bar<T> {
    private @XmlValue T value;  // (*)
}

But I get this exception

(*) IllegalAnnotationException:
@XmlAttribute/@XmlValue need to reference a Java type that maps to text in XML.

Answer 1

The trick I'm usually using is to create schema with types you want and then use xjc to generate Java classes and see how annotations are used. :) I believe in XML schema proper type mapping for byte[] is 'base64Binary', so creating schema like this:

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.example.org/NewXMLSchema" xmlns:tns="http://www.example.org/NewXMLSchema" elementFormDefault="qualified">
    <element name="aTest" type="base64Binary"></element>
</schema>

and running xjc we would get following code generated:

@XmlElementDecl(namespace = "http://www.example.org/NewXMLSchema", name = "aTest")
public JAXBElement<byte[]> createATest(byte[] value) {
    return new JAXBElement<byte[]>(_ATest_QNAME, byte[].class, null, ((byte[]) value));
}

Answer 2

I couldn't get @XmlValue working as I always got NullPointerException along the way—not sure why. I came up with something like the following instead.

Drop your Bar class entirely, because, as you want it to be able to contain anything you can simply represent it with Object.

@XmlRootElement(name = "foo", namespace = "http://test.com")
@XmlType(name = "Foo", namespace = "http://test.com")
public class Foo {

  @XmlElement(name = "bar")
  public List<Object> bars = new ArrayList<>();

  public Foo() {}
}

Without telling JAXB which namespaces your types are using every bar element inside a foo would contain separate namespace declarations and stuff—the package-info.java and all the namespace stuff serves only fancification purposes only.

@XmlSchema(attributeFormDefault = XmlNsForm.QUALIFIED,
           elementFormDefault = XmlNsForm.QUALIFIED,
           namespace = "http://test.com",
           xmlns = {
               @XmlNs(namespaceURI = "http://test.com", prefix = ""),
               @XmlNs(namespaceURI = "http://www.w3.org/2001/XMLSchema-instance", prefix = "xsi"),
               @XmlNs(namespaceURI = "http://www.w3.org/2001/XMLSchema", prefix = "xs")})
package test;

import javax.xml.bind.annotation.XmlNs;
import javax.xml.bind.annotation.XmlNsForm;
import javax.xml.bind.annotation.XmlSchema;

Running this simple test would spout-out something similar to your XML snippet.

public static void main(String[] args) throws JAXBException {
  JAXBContext context = JAXBContext.newInstance(Foo.class);

  Foo foo = new Foo();
  foo.bars.add("a");
  foo.bars.add("b".getBytes());

  Marshaller marshaller = context.createMarshaller();
  marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
  marshaller.marshal(foo, System.out);
}

Output:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<foo xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://test.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <bar xsi:type="xs:string">a</bar>
    <bar xsi:type="xs:base64Binary">Yg==</bar>
</foo>

Answer 3

You could leverage an XmlAdapter for this use case instead of @XmlValue:

BarAdapter

package forum8807296;

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

public class BarAdapter extends XmlAdapter<Object, Bar<?>> {

    @Override
    public Bar<?> unmarshal(Object v) throws Exception {
        if(null == v) {
            return null;
        }
        Bar<Object> bar = new Bar<Object>();
        bar.setValue(v);
        return bar;
    }

    @Override
    public Object marshal(Bar<?> v) throws Exception {
        if(null == v) {
            return null;
        }
        return v.getValue();
    }

}

Foo

The XmlAdapter is associated with the bars property using the @XmlJavaTypeAdapter annotation:

package forum8807296;

import java.util.List;
import javax.xml.bind.annotation.*;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

@XmlRootElement
public class Foo {
    private List<Bar> bars;

    @XmlElement(name="bar")
    @XmlJavaTypeAdapter(BarAdapter.class)
    public List<Bar> getBars() {
        return bars;
    }

    public void setBars(List<Bar> bars) {
        this.bars = bars;
    }

}

Bar

package forum8807296;

public class Bar<T> {
    private T value;

    public T getValue() {
        return value;
    }

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

Demo

You can test this example using the following demo code:

package forum8807296;

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

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;

public class Demo {

    public static void main(String[] args) throws Exception {
        JAXBContext jc = JAXBContext.newInstance(Foo.class);

        Foo foo = new Foo();
        List<Bar> bars = new ArrayList<Bar>();
        foo.setBars(bars);

        Bar<String> stringBar = new Bar<String>();
        stringBar.setValue("string data");
        bars.add(stringBar);

        Bar<byte[]> binaryBar = new Bar<byte[]>();
        binaryBar.setValue("binary data".getBytes());
        bars.add(binaryBar);

        Marshaller marshaller = jc.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.marshal(foo, System.out);
    }

}

Output

Note how the output includes the xsi:type attributes to preserve the type of the value. You can eliminate the the xsi:type attribute by having your XmlAdapter return String instead of Object, if you do this you will need handle the conversion from String to the appropriate type yourself for the unmarshal operation:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<foo>
    <bar xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xs="http://www.w3.org/2001/XMLSchema" xsi:type="xs:string">string data</bars>
    <bar xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xs="http://www.w3.org/2001/XMLSchema" xsi:type="xs:base64Binary">YmluYXJ5IGRhdGE=</bars>
</foo>

Answer 4

https://stackoverflow.com/a/3074027/1851289 could be a duplicate, however the answer has other 2 options.

Answer 5

Is there a reason you don't simply construct a String with your byte[]? Do you truly need a generic?