Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs
Page 2 of 6
JDOM's second philosophy is that it should be fast and lightweight. Loading and manipulating documents should be quick, and memory requirements should be low. JDOM's design definitely allows for that. For example, even the early, untuned implementation has operated more quickly than DOM and roughly on par with SAX, even though it has many more features than SAX.
So, do you need JDOM? It's a good question. There are existing standards already, so why invent another one? The answer is that JDOM solves a problem that the existing standards do not.
DOM represents a document tree fully held in memory. It is a large API designed to perform almost every conceivable XML task. It also must have the same API across multiple languages. Because of those constraints, DOM does not always come naturally to Java developers who expect typical Java capabilities such as method overloading, the use of standard Java object types, and simple set and get methods. DOM also requires lots of processing power and memory, making it untractable for many lightweight Web applications and programs.
SAX does not hold a document tree in memory. Instead, it presents a view of the document as a sequence of events. For example, it reports every time it encounters a begin tag and an end tag. That approach makes it a lightweight API that is good for fast reading. However, the event-view of a document is not intuitive to many of today's server-side, object oriented Java developers. SAX also does not support modifying the document, nor does it allow random access to the document.
JDOM attempts to incorporate the best of DOM and SAX. It's a lightweight API designed to perform quickly in a small-memory footprint. JDOM also provides a full document view with random access but, surprisingly, it does not require the entire document to be in memory. The API allows for future flyweight implementations that load information only when needed. Additionally, JDOM supports easy document modification through standard constructors and normal set methods.
JDOM represents an XML document as an instance of the
org.jdom.Document class. The
Document class is a lightweight class that can hold a
ProcessingInstruction objects, a root
Comment objects. You can construct a
Document from scratch without needing a factory:
Document doc = new Document(new Element("rootElement"));
In the next article, we'll discuss how easy it is to create an XML structure from scratch using JDOM. For now we'll construct our documents from a preexisting file, stream, or URL:
SAXBuilder builder = new SAXBuilder(); Document doc = builder.build(url);
You can build documents from any data source using builder classes found in the
org.jdom.input package. Currently there are two builders,
SAXBuilder uses a SAX parser behind the scenes to build the
Document from the file; the
SAXBuilder listens for the SAX events and builds a corresponding
Document in memory. That approach is very fast (basically as fast as SAX), and it is the approach we recommend.
DOMBuilder is another alternative that builds a JDOM
Document from an existing
org.w3c.dom.Document object. It allows JDOM to interface easily with tools that construct DOM trees.