XML is a general-purpose specification for creating custom mark-up languages. It is classified as an extensible language because it allows its users to define their own elements. Its primary purpose is to help information systems share structured data, particularly via the Internet, and it is used both to encode documents and to serialize data. In the latter context, it is comparable with other text-based serialization languages such as JSON and YAML.

As a diverse platform, Java has several solutions for working with XML. This refcard provides developers a concise overview of the different xml processing technologies in Java, and a use case of each technology.

1 <?xml version=”1.0” encoding=”UTF-8”?>
2 <!DOCTYPE publications SYSTEM “publications.dtd”>
3 <publications
4 xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
5 xsi:schemaLocation=”http://xml.dzone.org/schema/publications
6 publications.xsd”
7 xmlns=”http://xml.dzone.org/schema/publications”
8 xmlns:extras=”http://xml.dzone.org/schema/publications”>
9    <book id=”_001”>
10      <title>Beginning XML, 4th Edition </title>
11     <author>David Hunter</author>
12     <copyright>2007</copyright>
13     <publisher>Wrox</publisher>
14     <isbn kind=”10”>0470114878</isbn>
15   </book>
16   <book id=”_002”>
17     <title>XML in a Nutshell, Third Edition</title>
18     <author>O’Reilly Media, Inc</author>
19     <copyright>2004</copyright>
20     <publisher>O’Reilly Media, Inc.</publisher>
21     <isbn kind=”10”>0596007647</isbn>
22   </book>
23   <extras:book id=”_003” image=”erik_xml.jpg”>
24     <title>Learning XML, Second Edition</title>
25     <author>Erik Ray</author>
26     <copyright>2003</copyright>
27     <publisher>O’Reilly Media, Inc.</publisher>
28     <isbn kind=”10”>0596004206</isbn>
29   </extras:book>
30 </publications>

XML File Sample, Continued

Capabilities of Element and Attribute

XML Use Cases

In order to use a XML file or a XML document inside an application, it will be required to read it and tokenize it. For the XML files, this is called XML Parsing and the piece of software which performs this task is called a Parser.

There are two general parsing techniques:

• In Memory Tree: The entire document is read into memory as a tree structure which allows random access to any part of the document by the calling application.
• Streaming (Event processing): A Parser reads the document and fires corresponding event when it encounters XML entities.

Two types of parsers use streaming techniques:

• Push parsers: Parsers are in control of the parsing and the parser client has no control over the parsing flow.
• Pull parsers: The Parser client is in control of the parsing and the parser goes forward to the next infoset element when it is asked to.

Following are parsers generally available in the industry:

• DOM: DOM is a tree-based parsing technique that builds up an entire parse tree in memory. It allows complete dynamic access to a whole XML document.
• SAX: SAX is an event-driven push model for processing XML. It is not a W3C standard, but it’s a very well recognized API that most SAX parsers implement in a compliant way. Rather than building a tree representation of an entire document as DOM does, a SAX parser fires off a series of events as it reads through the document.
• StAX (JSR 173): StAX was designed as a median between DOM and SAX. In StAX, the application moves the cursor forward ‘pulling’ the information from the parser as it needs. So there is no event firing by the parser or huge memory consumption. You can use 3rd party libraries for Java SE 5 and older or bundled StAX parser of Java SE 6 and above.

Parsing Techniques, Continued

All of these parsers fall under JAXP implementation. The following sample codes show how we can utilize Java SE 6 XML processing capabilities for XML parsing.

14 DocumentBuilderFactory factory = DocumentBuilderFactory.
15 newInstance();
16 factory.setValidating(true);
17 factory.setNamespaceAware(true);
18 factory.setAttribute(“http://java.sun.com/xml/jaxp/properties
19 /schemaLanguage”, “http://www.w3.org/2001/XMLSchema”);
20 DocumentBuilder builder = factory.newDocumentBuilder();
21 builder.setErrorHandler(new SimpleErrorHandler());
22 Document doc = builder.parse(“src/books.xml”);
23 NodeList list = doc.getElementsByTagName(“*”);
24 for (int i = 0; i < list.getLength(); i++) {
25              Element element = (Element) list.item(i);
26              System.out.println(element.getNodeName() + “ “ +
27              element.getTextContent());
28              if (element.getNodeName().equalsIgnoreCase(“book”)) {
29                      System.out.println(“Book ID= “ + element
30                      getAttribute(“id”));
31               }
32      if (element.getNodeName().equalsIgnoreCase(“isbn”)) {
33                       System.out.println(“ISBN Kind=” + element
34                      getAttribute(“kind”));
35              }

11 public class SimpleErrorHandler implements ErrorHandler {
12
13       public void warning(SAXParseException e) throws SAXException
{
14               System.out.println(e.getMessage());
15       }
16
17       public void error(SAXParseException e) throws SAXException {
18         System.out.println(e.getMessage());
19       }
20
21       public void fatalError(SAXParseException e) throws SAXException {
22              System.out.println(e.getMessage());
23  }
24 }
25 }

For using SAX, we need the parser and an event handler that should respond to the parsing events. Events can be a start element event, end element event, and so forth.

A simple event handler might be:

public class SimpleHandler extends DefaultHandler {

public void startElement(String namespaceURI, String localName,
        String qName, Attributes atts)
        throws SAXException {
  if (“book”.equals(localName)) {
        System.out.print(“Book details: Book ID: “ + atts
        getValue(“id”));
  } else {
        System.out.print(localName + “: “);
        }
}
public void characters(char[] ch, int start, int length)
        throws SAXException {
  System.out.print(new String(ch, start, length));
}
  public void endElement(String namespaceURI, String localName,
  String qName)
        throws SAXException {
  if (“book”.equals(localName)) {
        System.out.println(“=================================”);
        }
  }
}

The parser code that uses the event handler to parse the book. xml document might be:

SAXParser saxParser;
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setNamespaceAware(true);
factory.setValidating(true);
saxParser = factory.newSAXParser();
saxParser.setProperty(
        “http://java.sun.com/xml/jaxp/properties/schemaLanguage”,
  “http://www.w3.org/2001/XMLSchema”);
XMLReader reader = saxParser.getXMLReader();
reader.setErrorHandler(new SimpleErrorHandler());
reader.setContentHandler(new SimpleHandler());
reader.parse(“src/books.xml”);

StAX is a streaming pull parser. It means that the parser client can ask the parser to go forward in the document when it needs. StAX provides two sets of APIs:

• The cursor API methods return XML information as strings, which minimizes object allocation requirements.
• Iterator-based API which represents the current state of the parser as an Object. The parser client can get all the required information about the element underlying the event from the object.

Differences and features of StAX APIs

XMLInputFactory inputFactory = XMLInputFactory.newInstance();
InputStream in = new FileInputStream(“src/books.xml”);
XMLEventReader eventReader = inputFactory.createXMLEventReader(in);
while (eventReader.hasNext()) {
 XMLEvent event = eventReader.nextEvent();
 if (event.isEndElement()) {
   if (event.asEndElement().getName().getLocalPart()
   equals(“book”)) {
        event = eventReader.nextEvent();
        System.out.println(“=================================”);
        continue;
}
}
if (event.isStartElement()) {
if (event.asStartElement().getName().getLocalPart()
equals(“title”)) {
        event = eventReader.nextEvent();
        System.out.println(“title: “ + event.asCharacters()
        getData());
        continue;
}
if (event.asStartElement().getName().getLocalPart()
equals(“author”)) {
        event = eventReader.nextEvent();
        System.out.println(“author: “ + event.asCharacters()
        getData());
        continue;
}
if (event.asStartElement().getName().getLocalPart()
equals(“copyright”)) {
        event = eventReader.nextEvent();
        System.out.println(“copyright: “ + event
        asCharacters().getData());
        continue;
}
if (event.asStartElement().getName().getLocalPart()
equals(“publisher”)) {
        event = eventReader.nextEvent();
        System.out.println(“publisher: “ + event.asCharacters()
        getData());
        continue;
}
if (event.asStartElement().getName().getLocalPart()
equals(“isbn”)) {
        event = eventReader.nextEvent();
        System.out.println(“isbn: “ + event.asCharacters()
        getData());
        continue;
}
}
}

There are two levels of correctness of an XML document:

1. Well-formed-ness. A well-formed document conforms to all of XML’s syntax rules. For example, if a start-tag appears without a corresponding end-tag, it is not well-formed. A document that is not well-formed is not considered to be XML.

Sample characteristics:

• XML documents must have a root element
• XML elements must have a closing tag
• XML tags are case sensitive
• XML elements must be properly nested
• XML attribute values must always be quoted

1. Validity. A valid document conforms to semantic rules. The rules are included as XML schema, especially DTD. Examples of invalid documents include: if a required attribute or element is not present in the document; if the document contains an undefined element; if an element is meant to be repeated once, and appears more than once; or if the value of an attribute does not conform to the defined pattern or data type.

XML Structure, Continued

XML validation mechanisms include using DTD and XML schema like XML Schema and RelaxNG.

Document Type Definition (DTD)

A DTD defines the tags and attributes used in a XML or HTML document. Elements defined in a DTD can be used, along with the predefined tags and attributes of each markup language. DTD support is ubiquitous due to its inclusion in the XML 1.0 standard.

A sample DTD document

1  <?xml version=”1.0” encoding=”UTF-8”?>
2  <!ELEMENT publications (book*)>
3  <!ELEMENT book (title, author+, copyright, publisher, isbn,
4  description?)>
5  <!ELEMENT title (#PCDATA)>
6  <!ELEMENT author (#PCDATA)>
7  <!ELEMENT copyright (#PCDATA)>
8  <!ELEMENT publisher (#PCDATA)>
9  <!ELEMENT isbn (#PCDATA)>
10 <!ELEMENT description (#PCDATA)>
11 <!ATTLIST book id ID #REQUIRED image CDATA #IMPLIED>
12 <!ATTLIST isbn kind (10|13) #REQUIRED >

DTD Attribute Types

XML Schema Definition (XSD)

XSD provides the syntax and defines a way in which elements and attributes can be represented in a XML document. It also advocates the XML document should be of a specific format and specific data type. XSD is fully recommended by the W3C consortium as a standard for defining a XML Document. XSD documents are written in XML format.

A sample XSD document

1 <?xml version=”1.0” encoding=”UTF-8”?>
2 <xs:schema xmlns:xs=”http://www.w3.org/2001/XMLSchema”
3         xmlns:extras=”http://xml.dzone.org/schema/publications”
4         attributeFormDefault=”unqualified” elementFormDefault=”unqualified”
5         xmlns=”http://xml.dzone.org/schema/publications”
6         targetNamespace=”http://xml.dzone.org/schema/publications”
7         version=”4”>
8       <xs:element name=”publications”>
9         <xs:complexType>
10       <xs:sequence>
11                      <xs:element minOccurs=”0” maxOccurs=”unbounded”
12                      ref=”book”/>
13       </xs:sequence>
14    </xs:complexType>
15 </xs:element>
16 <xs:element name=”book”>
17    <xs:complexType>
18               <xs:sequence>
19         <xs:element ref=”title”/>
20                 <xs:element minOccurs=”1” maxOccurs=”unbounded”
21                 ref=”author”/>
22                 <xs:element ref=”copyright”/>
23                 <xs:element ref=”publisher”/>
24                 <xs:element ref=”isbn”/>
25                 <xs:element minOccurs=”0” ref=”description”/>
26       </xs:sequence>
27       <xs:attributeGroup ref=”attlist.book”/>
28    </xs:complexType>
29 </xs:element>
30 <xs:element name=”title” type=”xs:string”/>
31 <xs:element name=”author” type=”xs:string”/>
32 <xs:element name=”copyright” type=”xs:string”/>
33 <xs:element name=”publisher” type=”xs:string”/>
34 <xs:element name=”isbn”>
35    <xs:complexType mixed=”true”>
36                 <xs:attributeGroup ref=”attlist.isbn”/>
37    </xs:complexType>
38 </xs:element>
39 <xs:element name=”description” type=”xs:string”/>
40 <xs:attributeGroup name=”attlist.book”>
41        <xs:attribute name=”id” use=”required” type=”xs:ID”/>
42    <xs:attribute name=”image”/>
43 </xs:attributeGroup>
44 <xs:attributeGroup name=”attlist.isbn”>
45    <xs:attribute name=”kind” use=”required”>
46         <xs:simpleType>
47                        <xs:restriction base=”xs:token”>
48                                <xs:enumeration value=”10”/>
49                            <xs:enumeration value=”13”/>
50            </xs:restriction>
51         </xs:simpleType>
52     </xs:attribute>
53   </xs:attributeGroup>
54 </xs:schema>

XML Schema Definition (XSD), Continued

To validate XML files using external XSD, replace line 17 – 20 of the DOM sample with:

factory.setValidating(false);
factory.setNamespaceAware(true);
SchemaFactory schemaFactory = SchemaFactory.newInstance("http:/www.w3.org/2001/XMLSchema");
factory.setSchema(schemaFactory.newSchema(new Source[]{new StreamSource("src/publication.xsd"))});

XML Schema validation factors

XML Schema built-in types

DTD and XSD validation capabilities

XPath is a declarative language used for referring to sections of XML documents. XPath expressions are used for locating a set of nodes in a given XML document. Many XML technologies, like XSLT and XQuery, use XPath extensively. To use these technologies, you’ll need to understand the basics of XPpath. All samples in this section assume we are working on a XML document similar to the XML document on page 1.

Sample XPath Expressions and Output

As you can see, contains and positions functions are two widely used XPath functions.

Important XPath Functions

Using XPath in a Java Application

17 Document xmlDocument;
18 DocumentBuilderFactory dbFactory = DocumentBuilderFactory.
19 newInstance();
20 DocumentBuilder builder = dbFactory.newDocumentBuilder();
21 xmlDocument = builder.parse(“src/books.xml”);
22 XPathFactory factory = XPathFactory.newInstance();
23 XPath xPath = factory.newXPath();
24 String copyright = xPath.evaluate
25           (“/publications/book[publisher= ‘Wrox’]/copyright”, xmlDocument);
26 System.out.println(“Copyright: “ + copyright);
27 NodeList nodes = (NodeList) xPath.evaluate(“//book”, xmlDocument,
28 XPathConstants.NODESET);
29 String bookid = xPath.evaluate
30     (“/publications//book[contains(title,’XML’) and position()=3]/@id”,
31   xmlDocument);
32 System.out.println(“Book ID: “ + bookid);