Introduction
These examples show various techniques for processing XML with JAXB.
Note that you will need Java 1.4 to compile these examples.
Path names are currently hard-coded in the example files,
so you'll need to modify these before compiling.
Here's a simple example file that you can use for testing:
Parsing XML
The first set of examples show how to parse existing XML files.
There are two main approaches: SAX and DOM.
Parsing with SAX
The first approach, which uses SAX (Simple API for XML),
essentially converts the XML document into a stream of events.
You need to define a 'handler' that receives those events; it must
implement the ContentHandler interface.
In the following example, a basic handler that implements
ContentHandler directly is used.
SAX also provides a default handler that implements
ContentHandler and provides do-nothing methods for all of
the necessary methods.
We can simplify the example above by deriving our content
handler from the default handler, and just implementing
the methods that we need to override.
Parsing with DOM
The second approach uses the DOM (Document Object Model),
and builds a tree representation of the document in
memory, which can then be traversed and manipulated.
In general, DOM uses far more memory than SAX, while
programs using DOM are simpler than those that use SAX.
Generating XML
The second set of examples show how to generate XML files
from scratch.
Generating XML with Print Statements
The naive approach is to simply use print statements.
This approach works in for short documents, but there are
several potential weaknesses.
The biggest problem is to remember to escape the special
characters that cannot appear in XML text, such as <.
Another problem is simply a software engineering problem:
different programmers will use different techniques for
organizing the generation code, leading to endless
confusion.
It is much better to use a standardized approach.
Generating XML with DOM
One common technique that can be used is to build the
document as a DOM tree in memory.
This approach can be costly in terms of memory consumption,
however, if the document is large.
The following example shows this approach:
Generating XML with SAX
Another approach is based on the idea of simulating a SAX
parser.
The idea is to generate a series of SAX events by calling
methods in the ContentHandler interface.
The resulting event stream can be converted directly into an
XML document.
The simplest way to perform the conversion is to use an
identity XSLT transformation, and that's what we use in
the following examples.
In the first example, we create a default implementation
of XMLReader, and then a subclass which actually generates
the SAX events.
The event stream is converted to a file by means of an
identity XSLT transformation.
It's awkward to have to implement all the methods of
XMLReader, though.
Another approach is to use XMLFilter instead, since SAX
conveniently provides a default implementation of this
interface, namely XMLFilterImpl.
The following example is considerably simpler:
Perhaps the simplest variation of this approach uses
a TransformerHandler. Unfortunately, it's not so easy
to example what is actually going on in this example!
Transforming XML
Many large systems are based on the notion of streams
of XML make their way through various components, and
undergoing transformations in the process. There are two
basic mechanisms for transforming a stream of XML: XML filters
and XSLT transformations.
Transforming XML with SAX Filters
XML filters are based on the SAX model, and are typically
hooked up to a SAX parser, so that the events generated
by the parser pass through the filter on the way to the
destination. Multiple filters can actually be chained
together to apply various bits of processing as the stream
passes through the pipeline.
The first example shows a single filter:
The second example shows a chain of filters:
Transforming XML with XSLT
A different, and more general approach is to use XSLT
transformations.
In this approach, the required transformation is defined
by means of an XSL file.
XSLT is in fact a functional programming language.
Here's an XSLT file that can be applied to the example
XML file accessible at the top of this page.
And here's an example that shows how to apply the
transformation: