Question

How might I marshall an object hierarchy such that, instead of having the component objects becoming nested XML elements, their properties become direct children of the root element with their names prefixed by their type.

For example, given:

                                                    (A)
public class Customer {

    protected String firstName;
    protected String lastName;
    protected Address address;
}

public class Address {

    protected String street;
    protected String city;
}

Using the usual JAXB annotations would result in

                                                    (B)
<customer>
    <firstName>Juan</firstName>
    <lastName>dela Cruz</lastName>
    <address>
        <street>123 Rizal Avenue</street>
        <city>Manila</city>
    </address>
</customer>

But, instead, I need to marshall the same as

                                                    (C)
<customer>
    <firstName>Juan</firstName>
    <lastName>dela Cruz</lastName>
    <address_street>123 Rizal Avenue</address_street>
    <address_city>Manila</address_city>
</customer>

It would be great if there were some JAXB incantation to solve my needs since I’m already using JAXB for most of the things around this problem. In fact, these present some constraints to my specific situation:

1. The Java classes in (A) are generated by JAXB from an existing schema that corresponds to the XML structure in (B). I would prefer not to maintain modified versions of the generated classes.
2. I do not own or maintain the said schema. The actual schema is quite large and is often subject to minor modifications. It would be tedious to come up with and maintain an equivalent schema. Also, to keep up with schema modifications, I rely on the automated class generation by JAXB.
3. If it makes things easier, nesting is only up to one level deep. In the example, Address would not contain any other complex type.

I’m looking at the @XmlPath annotation from MOXy, but I can’t figure out how to get the node names prefixed as in (C).

I dream of a solution where some xjc customizations providing the right JAXB annotations get me going, but that’s looking unlikely from my searches so far. Any non-JAXB solution would suffice.

Answer 1

I solved this using an XStream Converter. It checks for the @XmlType annotation to determine if a JAXB bean is being converted. All other types go through the default converters.

Though a JAXB-centric solution would have been nice, XStream provided a compellingly straightforward solution.

public class FlatXmlConverter implements Converter {

    private static final Logger log =
            LoggerFactory.getLogger(NvpConverter.class);

    @Override
    public void marshal(Object source, HierarchicalStreamWriter writer,
            MarshallingContext context) {
        Class<? extends Object> sourceClass = source.getClass();
        String prefix = (String) context.get("prefix");
        for (Field field : sourceClass.getDeclaredFields()) {
            if (!field.isAccessible()) {
                field.setAccessible(true);
            }
            String name = field.getName();
            Class<?> type = field.getType();

            try {
                Object value = field.get(source);
                if (value != null) {
                    if (type.isAnnotationPresent(XmlType.class)) {
                        context.put("prefix", name);
                        context.convertAnother(value);
                        context.put("prefix", null);
                    } else {
                        String nodeName;
                        if (prefix == null) {
                            nodeName = name;
                        } else {
                            nodeName = prefix + "_" + name;
                        }

                        writer.startNode(nodeName);
                        context.convertAnother(value);
                        writer.endNode();
                    }
                }
            } catch (IllegalArgumentException ex) {
                log.error("IllegalArgumentException", ex);
            } catch (IllegalAccessException ex) {
                log.error("IllegalAccessException", ex);
            }
        }
    }

    @Override
    public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    @SuppressWarnings({"rawtypes", "unchecked"})
    public boolean canConvert(Class type) {
        log.debug("canConvert({})", type);
        return type.isAnnotationPresent(XmlType.class);
    }
}