Java Automating XML/Java mapping with Jato

Automating XML/Java mapping with Jato

Java applications that deal with XML, often must resort to tedious parsing
and mapping code. Data binding is gradually emerging as an effective mechanism
for incorporating XML data into Java applications. The plus side to this
approach is that XML data will look like Java objects which makes it easier for
the Java programmer to manipulate and interact with that data. Such mapping are
usually a two-way street in that they can also take a Java object and serialize
it into XML. The negative side would be performance (by introducing some
overhead) and the inherent incompatibility that exists among the different
binding mechanism.

Jato, is an open-source effort focusing on XML/Java conversion

Jato, is an open-source effort focusing on XML/Java conversion (http://www.krumel.com/jato
). Jato encapsulates the mapping between XML and Java objects into an XML file
(using Jato-specific tags). This allows the developer to focus strictly on the
mapping without paying too much attention to implementation. As the author of
Jato observes, conversion implementations often have similar patterns. By
capturing the mapping in a single place and then allowing Jato handle the
parsing, conversion, and generation, you save many lines of code.

Writing a Jato script is similar to writing an XSLT stylesheet. When going
from Java to XML, you can use the JavaToXml class. After instantiating it, you
need to specify the root element to be used for the output XML and specify a
"helper" class via the setHelperclass()
method. The helper class is the interface between the Jato script (containing
the mapping and instructions) and the Java application. When going the other way
(from XML to Java), you can use the XmlToJava class. Again, there is a helper
class you can use as the interface between Jato script and the application.

Within a Jato script, anything outside the Jato namespace, directly goes to
the output. This allows you to easily provides a structure around the
application specific data and change it without modifying any Java code. The
rest of the script consists of Jato-specific tags. For example, the <Jato:attribute>
element adds an attribute to the output XML file. The <Jato:if> element
along with the <Jato:else> element allow for a conditional test to be done
which could alter the output XML file. Inside the Jato script, you have access
to instances of objects from the Java application and can retrieve their
properties or invoke their methods. If the underlying objects are JavaBeans,
then the naming convention can be used to make the mapping easier to follow.

The engine responsible for parsing Jato scripts and performing the
instructions actually uses JDOM to interact with XML. JDOM is an open-source API
for XML manipulation from Java (www.jdom.org).
Jato script elements all have a Java implementation which you can examine by
looking at the source. Furthermore, you can create your own Jato tags by
implementing specific interfaces. This is very important, because you can extend
the functionality of Jato to fit your needs. Furthermore, the behavior of the
application can be modified by merely changing the Jato script file without
touching any of the actual Java code. This is also a promise of XSLT, but Jato
offers a two-way street and the binding between XML elements and Java objects is
more intuitive and natural. In that regards, Jato is closer to Java/XML data
binding tools like Zeus (from Enhydra) than transformations done via XSLT.

Jato is still under development, but you can get a glimpse of what it can do
by looking at the examples and the sample code. And of course, in the spirit of
open-source software, you can always join the team of Jato developers to make it
even better.

About the Author

Piroz Mohseni is president of Bita
Technologies, focusing on business improvement through the effective use of
technology. His areas of interest include enterprise Java, XML, and e-commerce
applications.

Latest Posts

Related Stories