XML Reference Guide

If you're an object-oriented programmer, you probably gravitated towards the Document Object Model for manipulating your XML data. DOM is handy, in that it's widely supported, it lets you manage your data in an almost tangible way, and it lets you make changes to the Document in memory. Oh sure, it's not the only way to manipulate XML data, and in some cases, it's not even the best way. But it's the most common way, and for most of us, it was our first way.

Of course, there are certain ... annoyances when it comes to working with the Document Object Model. For example, reading a document from a file is fine, but what if you want to create one from scratch? For that matter, how do you create a parser? Output the data? These are all issues that suffer from irritations stemming from a lack of standardization or just downright difficulty. And don't even get me started on moving a Node from one Document to another!

Fortunately, I'm not the only one to notice these problems. In fact, developers started complaining about them way back when the DOM was first introduced, so it was inevitable that someone would take up the cause and solve them. Enter the Document Object Model, Level 3. DOM Level 3 consists of several different recommendations and notes:

• DOM Level 3 Core: The DOM Level 3 Core Recommendation's big claim to fame is the specification of "bootstrapping", or a standard way in which to create a DOM Document (or specifically, a DocumentImplementation) from scratch. Previously, the fact that everything was defined as interfaces made it necessary to "hard-code" the creation of a Document to a particular implementation. In other words, you couldn't run your Xerces-Java code in a JAXP implementation. The Core also clears up some issues regarding namespace resolution and adds the abililty to create a DOMConfiguration. Another interesting feature of DOM Level 3 is the ability to bind your own non-XML data to a Document via the new DOMUserData type. This Recommendation also introduces some new methods to existing objects, making it possible to move Nodes between Documents, normalize Documents, and solve other problems that have aggravated developers for years.
• DOM Level 3 Load and Save: If the ability to easily load and save an XML Document object seems insignificant to you, then either you've never done it or you've gotten used to jumping through hoops such as performing an XSL identity transformation just to send your XML out to a file. This Recommendation defines a standard way to not only create and configure a parser, but also to specify an output location, configure the output, and actually output your XML to a destination.
• DOM Level 3 Validation: This recommendation solves the problem of creating a document that is not only valid when you parse it, but also after you've edited it. It creates the ability to validate a document "on demand", as well as the ability to prevent non-valid changes to the document. It also gives you the ability to know what changes are permitted at a particular node (in order to list available options, for example) or to know whether a particular change is valid.
• DOM Level 3 XPath Working Group Note: If you've ever tried to get to a specific node within a Document object, you'll appreciate an implementation of this document. It defines the means by which a DOM implementation can enable you to select a Node or Nodes based on an XPath expression, just as you would in an XSL Transformation. This document is not a recomendation, as the Working Group doesn't expect to get two implementations that use the same binding.
• DOM Level 3 Views and Formatting Working Group Note: This document builds on the DOM Level 2 Views Recommendation, but at the moment doesn't see a lot of activity.

In order to use the Document Object Model Level 3, you need to have an implementation handy, which at the time of this writing is easier said than done. Because I'm predisposed toward Java, Here are the instructions for making DOM Level 3 available to you:

1. Install Java. You can download it from java.sun.com. I'm using Java 1.4.x for these instructions. Hopefully the final release of Java 1.5 will have this capability included and this will be a moot point.
2. Download beta2-dom3-Xerces-J-bin.2.6.2.zip from Apache and extract the files from it.
3. Create the directories <javahome>/lib/endorsed and <javahome>/jre/lib/endorsed and add the dom3-xercesImpl.jar and dom3-xml-apis.jar files to both.
4. You may also need to add the jar files to your classpath, although technically that shouldn't be necessary.
5. In order to get the documentation, download the Xerces source and tools distributions. Unpack both.
6. Copy the tools directory to the xerces-2_6_2 directory (or whatever directory you chose for the source files).
7. Open a command prompt window and change to the xerces-2_6_2 directory.
8. Type build javadocs to generate the API documentation. Note that this documentation is different from what appears in the samples on the Xerces website. (You can also use build jar-dom3 and build apijar-dom3 to generate newer versions of the dom3-xercesImpl.jar and dom3-xml-apis.jar files.)
9. Now you can test your installation. Create a small XML file called personal.xml and save it in the directory in which you'll create your new class.
10. Create a new Java class:

    import org.w3c.dom.bootstrap.DOMImplementationRegistry;
    import org.w3c.dom.DOMImplementationList;
    import org.w3c.dom.ls.DOMImplementationLS;
    import org.w3c.dom.ls.LSParser;
    import org.w3c.dom.Document;
    import org.w3c.dom.ls.LSSerializer;
    import org.w3c.dom.ls.LSOutput;
    
    public class testDom {
    
       public static void main (String args[]){
    
          try {
             System.setProperty(DOMImplementationRegistry.PROPERTY,
                    "org.apache.xerces.dom.DOMImplementationSourceImpl");
             DOMImplementationRegistry registry = 
                    DOMImplementationRegistry.newInstance();
             DOMImplementationLS impl = 
                    (DOMImplementationLS)registry.getDOMImplementation("LS");
             LSParser builder = impl.createLSParser(
                    DOMImplementationLS.MODE_SYNCHRONOUS, null);
    
             Document document = builder.parseURI("personal.xml");
    
             LSSerializer writer = impl.createLSSerializer();
             LSOutput output = impl.createLSOutput();
             output.setSystemId("file:///personalout.xml");
             writer.write(document, output);
          } catch (Exception e){
             System.out.println(e.toString());
          }
       }
    }

11. Compile and run the class. You should see a new file, personalout.xml, in the root directory.

Of course, there's a lot of new information here, and in the coming weeks, I'll be going over it to explain how DOM Level 3 works, but for now, just compile and run the application to make sure it works.