What is a good library for generating arbitrary XML from Java?

Question

I need to generate a number of XML documents from Java objects. The objects are deep ORM mapped objects, and the XML documents are for a search index (a la Lucene). I want to be able to create a configuration file and feed it a Java object and have it spit out the XML specified in the configuration. Ideally the configuration would consist of a mapping of (possibly deep) properties on the java side to XPath or something very much like it on the XML side.

JAXB is unsuitable because it wants to the create a one to one mapping from object data to XML nodes. I've looked at JIBX and XStream but neither of them seem to be designed to do what I'm talking about.

Essentially what I want is Dozer, but designed to create an XML document as its target rather than another Java bean. From my research so far it looks like I'm going to have to write this myself. Can anyone offer a better alternative?

EDIT: The solution must not be predicated on the ability to modify the source Java files. Annotation based systems are comepletely useless to my purposes here. It should be possible to define 'translators' for the individual mappings just as it is in Dozer.

It should be noted that I need to be able to specify that a given input field in java might be output in several different places in the XML output, perhaps being transformed in some cases and not in others.

I've already considered doing some sort of straight Java to XML translation of the objects and then performing my task using XSLT, but the problem with that is that these are deep objects with bidirectional connections. Any mapping of the objects to XML would have a difficult time figuring out how deep in object hierarchy to go, even if it could keep track of which objects should be discounted because they'd been seen already.

Answer 1

i use this: Simple

Answer 2

Have you looked at Castor?

In particular, this quote from their web page makes me think that it might do what you want:

Although it is possible to rely on Castor's default behavior to marshal and unmarshal Java objects into an XML document, it might be necessary to have more control over this behavior. For example, if a Java object model already exists, Castor XML Mapping can be used as a bridge between the XML document and that Java object model.

Castor allows one to specify some of its marshalling/unmarshalling behavior using a mapping file. This file gives explicit information to Castor on how a given XML document and a given set of Java objects relate to each other.

Another possibility might be JXM; from their webpage:

Java XML Mapping (JXM) is a tool for writing Java objects to XML and reading them back again. JXM provides a default mapping so that Java objects that follow Java Bean naming conventions can be written to XML by calling a single method. The default mapping can be customized by creating and registering mapping classes with the JXM framework.

JXM differs from other XML binding tools by not requiring objects to include or inherit from JXM code. No generated code is included in the objects, and they don't need to implement JXM interfaces. Customization is done by writing Java code rather than XML descriptors.

Answer 3

Take a look at Xmappr.

It can be configured via external XML. You can have several mappings that produce different outputs from same input object.

Also we are willing to help - just ask on the mailing list.

Answer 4

We have used Apache Velocity in the past as a means of keeping it simple.

Simply create a template for the XML, populate a data structure and inject the data structure in the map. It allows you to change the XML at run time if you need to (so long as your data structure has all the fields).

This is a very quick and flexible way to produce a document, it doesn't create a DOM and so is pretty parsimonious with memory.

Answer 5

Xstream is good

Answer 6

The solution you want is EclipseLink MOXy:

MOXy is a JAXB implementation with Extensions

MOXy has an external configuration file (based on JAXB annotations with extensions):

• http://wiki.eclipse.org/EclipseLink/Examples/MOXy/EclipseLink-OXM.XML

Has XPath based mapping, for deep mapping:

• http://bdoughan.blogspot.com/2010/07/xpath-based-mapping.html
• http://bdoughan.blogspot.com/2010/09/xpath-based-mapping-geocode-example.html

Designed to handle ORM mapped objects, including support for bidirectional relationships:

• http://wiki.eclipse.org/EclipseLink/Examples/MOXy/JPA
• http://bdoughan.blogspot.com/2010/07/jpa-entities-to-xml-bidirectional.html

Answer 7

You dont specify which ORM you use, but if by any chance it is hibernate, you can use it to do Java <-> XML mapping as well. The documentation is not as good as for DB mappings, but it is not that hard to use. The big advantage : you have one less dependency, one less framework to learn, and the concepts you have learn for DB mapping till mostly apply to XML mapping.

see : http://docs.jboss.org/hibernate/core/3.3/reference/en/html/xml.html

Answer 8

Take a look at XOM, it's super simple to build XML documents.

http://www.cafeconleche.org/XOM/