Java JAXP, Transforming XML to XHTML

Baldwin shows you how to use XSLT to transform an XML document into an XHTML document.  He also shows you how to write Java code to perform the same transformation.

Published:  August 24, 2004
By Richard G. Baldwin

Java Programming Notes # 2210

• Preface
• Preview
• Some Details Regarding XHTML
• Some Details Regarding XSLT
• Discussion and Sample Code
• The XSLT Transformation
• The Java Code Transformation
  
• Run the Program
• Summary
• What's Next?
• Complete Program Listings

In the previous lesson entitled Java JAXP, Writing Java Code to Emulate an XSLT Transformation, I showed you how to write a Java program that mimics an XSLT transformation for converting an XML file into a text file.  I also showed that once you have a library of Java methods that emulate XSLT elements, it is no more difficult to write a Java program to transform an XML document than it is to write an XSL stylesheet to transform the same document.

This lesson is one in a series designed to teach you how to use JAXP and Sun's Java Web Services Developer Pack (JWSDP).

JAXP, XML, XSL, XSLT, W3C, and XHTML, a Review

JAXP is an API designed to help you write programs for creating and processing XML documents. It is a critical part of Sun's Java Web Services Developer Pack (JWSDP).

• Transforming non-XML documents into XML documents.
• Transforming XML documents into other XML documents.
• Transforming XML documents into non-XML documents.

You may find it useful to open another copy of this lesson in a separate browser window.  That will make it easier for you to scroll back and forth among the different listings and figures while you are reading about them.

Supplementary material

I recommend that you also study the other lessons in my extensive collection of online Java and XML tutorials.  You will find those lessons published at Gamelan.com.  As of the date of this writing, Gamelan doesn't maintain a consolidated index of my tutorial lessons, and sometimes they are difficult to locate there.  You will find a consolidated index at www.DickBaldwin.com.

Preview

A tree structure in memory

A DOM parser can be used to create a tree structure in memory that represents an XML document.  In Java, that tree structure is encapsulated in an object of the interface type Document.

Many operations are possible

Given an object of type Document (often called a DOM tree), there are many methods that can be invoked on the object to perform a variety of operations.

Two ways to transform an XML document

There are at least two ways to transform the contents of an XML document into another document:

• By writing Java code to manipulate the DOM tree and perform the transformation.
• By using XSLT to perform the transformation.

A skeleton library of Java methods

This is one of several lessons that show you how to write the skeleton of a Java library containing methods that emulate the most common XSLT elements.  Once you have the library, writing Java code to transform XML documents consists mainly of writing a short driver program to access those methods.  Given the proper library of methods, it is no more difficult to write a Java program to perform the transformation than it is to write an XSLT stylesheet.

Library is not my primary purpose

However, my primary purpose in these lessons is not to provide such a library, but rather is to help you understand how to use a DOM tree to create, modify, and manipulate XML documents.  By comparing Java code that manipulates a DOM tree with similar XSLT operations, you will have an opportunity to learn a little about XSLT in the process of learning how to manipulate a DOM tree using Java code.

Some Details Regarding XHTML

XHTML documents, a special case

An XHTML document is an XML document.  It is a rigorous alternative to an HTML document. 

One of the interesting uses of XSLT is the transformation of XML documents into XHTML documents.  This makes it possible to render the information contained in an XML document using an XHTML-compatible Web browser.

Where does the transformation take place?

When transforming an XML document for rendering with an XHTML browser, the transformation can take place anywhere between the source of the XML document and the browser.

Transforming on the server

For example, a transformation program can be written in Java and run on a web server as a servlet, or it can be written as a JavaBeans component and accessed from a scriptlet in JavaServer pages (JSP).

Transforming at the browser

The transformation can also be performed by the browser.  For example, Microsoft IE 6.0 and XSLT can be used for this purpose.

Will transform XML into XHTML

This and the next several lessons will illustrate parallel Java code and XSLT transformations to transform XML documents into XHTML documents.  The sample programs will illustrate various aspects of the manipulation of a DOM tree using Java code.

According to Web Design & Development Using XHTML by Griffin, Morales, and Finnegan, an XHTML document differs from an HTML document in the following ways:

• XHTML documents must be well-formed.
• Element and attribute names must be in lower case.
• Non-empty elements require end tags.
• Attribute values must always be quoted.
• XHTML documents have no attribute minimization.
• XHTML documents end empty elements.
• XHTML documents use elements with id and name attributes.
• XHTML documents use Document Type Declarations
• XHTML documents use XML namespaces.

Some Details Regarding XSLT

Previous lessons in this series have provided quite a bit of detailed information regarding the operation of XSLT.  Therefore, this discussion will be brief.

Assume that an XML document has been parsed to produce a DOM tree in memory that represents the XML document.

Execute template rules

An XSLT processor starts examining the DOM tree at its root node.  It obtains instructions from the XSLT stylesheet telling it how to navigate the tree, and how to treat each node that it encounters along the way.

If the template rule being applied contains literal text, that literal text is used to create text in the output.

Traversal of the DOM tree

• xsl:apply-templates
  
• xsl:for-each
  

The xsl:apply-templates element

The xsl:apply-templates element was discussed in detail in previous lessons.

The xsl:for-each element executes an iterative examination of all child nodes of the context node that match a required select attribute.  As each child node is examined, it is processed using XSLT elements that form the content of the xsl:for-each element in the template rule.

This lesson will include examples that use the xsl:for-each element in addition to the xsl:apply-templates element.  The lesson will also explain a Java method that emulates the xsl:for-each element.

I will begin by discussing the XML file named Dom03.xml (shown in Listing 24 near the end of the lesson) along with the XSL stylesheet file named Dom03.xsl (shown in Listing 25).

A Java program named Dom03

After explaining the transformation produced by applying this stylesheet to this XML document, I will explain the transformation produced by processing the XML file with a Java program named Dom03 (shown in Listing 23) that mimics the behavior of the XSLT transformation.

#document DOCUMENT_NODE
  A DOCUMENT_TYPE_NODE
  #comment COMMENT_NODE
  xml-stylesheet PROCESSING_INSTRUCTION_NODE
  A ELEMENT_NODE
    Q ELEMENT_NODE
      #text A Big Header
    B ELEMENT_NODE
      C ELEMENT_NODE
        #text Text block 1.
      R ELEMENT_NODE
        #text A Mid Header
      C ELEMENT_NODE
        #text Text block 2.
      #comment COMMENT_NODE
      processor PROCESSING_INSTRUCTION_NODE
      S ELEMENT_NODE
        #text A Small Header
      B ELEMENT_NODE
        C ELEMENT_NODE
          #text Text block 3.
      S ELEMENT_NODE
        #text Another Small Header
      B ELEMENT_NODE
        C ELEMENT_NODE
          #text Text block 4.
        T ELEMENT_NODE
          #text A Smallest Header
        B ELEMENT_NODE
          C ELEMENT_NODE
            #text Text block 5.
          D ELEMENT_NODE
            E ELEMENT_NODE
              #text First list item in E
              G ELEMENT_NODE
                #text Nested G text element
            F ELEMENT_NODE
              #text First list item in F
            E ELEMENT_NODE
              #text Second list item in E
            F ELEMENT_NODE
              #text Second list item in F
            E ELEMENT_NODE
              #text Third list item in E
            F ELEMENT_NODE
              #text Third list item in F
          C ELEMENT_NODE
            #text Text block 6.
        C ELEMENT_NODE
          #text Text block 7.
      R ELEMENT_NODE
        #text Another Mid Header
      C ELEMENT_NODE
        #text Text block 8.
    B ELEMENT_NODE
      R ELEMENT_NODE
        #text Another Mid Header in Another B
      C ELEMENT_NODE
        #text Text block 9.

Figure 1

Figure 2 Rendered XHTML file

The XSLT Transformation

NOTE:  IT WAS NECESSARY TO MANUALLY ENTER SOME
LINE BREAKS IN THIS PRESENTATION TO FORCE IT TO
FIT INTO THIS NARROW PUBLICATION FORMAT.

#document DOCUMENT_NODE
  xsl:stylesheet ELEMENT_NODE
      Attribute: version=1.0
      Attribute: xmlns:xsl=http://www.w3.org/1999
                                   /XSL/Transform
    xsl:output ELEMENT_NODE
        Attribute: method=xml
        Attribute: doctype-public=-//W3C//DTD 
                       XHTML 1.0 Transitional//EN
        Attribute: doctype-system=http://www.w3.
        org/TR/xhtml1/DTD/xhtml1-transitional.dtd

    xsl:template ELEMENT_NODE
        Attribute: match=/
      html ELEMENT_NODE
        head ELEMENT_NODE
          meta ELEMENT_NODE
              Attribute: http-equiv=content-type
              Attribute: content=text/html; 
                                    charset=UTF-8
          title ELEMENT_NODE
            #text Generated XHTML file
        body ELEMENT_NODE
           table ELEMENT_NODE
              Attribute: border=2
              Attribute: cellspacing=0
              Attribute: cellpadding=0
              Attribute: width=330
              Attribute: bgcolor=#FFFF00
            tr ELEMENT_NODE
              td ELEMENT_NODE
                xsl:apply-templates ELEMENT_NODE

    xsl:template ELEMENT_NODE
        Attribute: match=B
      xsl:apply-templates ELEMENT_NODE

    xsl:template ELEMENT_NODE
        Attribute: match=C
      p ELEMENT_NODE
        xsl:apply-templates ELEMENT_NODE

    xsl:template ELEMENT_NODE
        Attribute: match=D
      #text List of items in E

      ul ELEMENT_NODE
        xsl:for-each ELEMENT_NODE
            Attribute: select=E
          li ELEMENT_NODE
            xsl:apply-templates ELEMENT_NODE
      #text List of items in F
      ol ELEMENT_NODE
        xsl:for-each ELEMENT_NODE
            Attribute: select=F
          li ELEMENT_NODE
            xsl:apply-templates ELEMENT_NODE

    xsl:template ELEMENT_NODE
        Attribute: match=G
      b ELEMENT_NODE
         xsl:apply-templates ELEMENT_NODE

    xsl:template ELEMENT_NODE
        Attribute: match=Q
      h1 ELEMENT_NODE
        xsl:apply-templates ELEMENT_NODE

    xsl:template ELEMENT_NODE
        Attribute: match=R
      h2 ELEMENT_NODE
        xsl:apply-templates ELEMENT_NODE

    xsl:template ELEMENT_NODE
        Attribute: match=S
      h3 ELEMENT_NODE
        xsl:apply-templates ELEMENT_NODE

    xsl:template ELEMENT_NODE
        Attribute: match=T
      h4 ELEMENT_NODE
        xsl:apply-templates ELEMENT_NODE

Figure 3

1. match=/ (root node)
2. match=B (matches element node named B)
3. match=C (matches element node named C)
4. match=D (matches element node named D)
5. match=G (matches element node named G)
6. match=Q (matches element node named Q)
7. match=R (matches element node named R)
8. match=S (matches element node named S)
9. match=T (matches element node named T)

NOTE THAT IT WAS NECESSARY FOR ME TO MANUALLY
INSERT LINE BREAKS IN SEVERAL OF THE LONG LINES
IN THIS MATERIAL TO FORCE IT TO FIT INTO THIS
NARROW PUBLICATION FORMAT.  I ALSO MANUALLY
INSERTED LINE BREAKS AT CRITICAL POINTS TO
MAKE IT EASIER TO INTERPRET THE MATERIAL 
VISUALLY.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 
     Transitional//EN" "http://www.w3.org/TR/
     xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" 
     xml:lang="en" lang="en">
<head>
<meta http-equiv="content-type" 
     content="text/html; charset=UTF-8"/>
<title>Generated XHTML file</title>
</head>
<body>
<table border="2" cellspacing="0" cellpadding="0"
      width="330" bgcolor="#FFFF00"><tr><td>
<h1>
A Big Header
</h1>
<p>
Text block 1.
</p>
<h2>
A Mid Header
</h2>
<p>
Text block 2.
</p>
<h3>
A Small Header
</h3>
<p>
Text block 3.
</p>
<h3>
Another Small Header
</h3>
<p>
Text block 4.
</p>
<h4>
A Smallest Header
</h4>
<p>
Text block 5.
</p>
List of items in E
<ul>
<li>
First list item in E
<b>
Nested G text element
</b>
</li>
<li>
Second list item in E
</li>
<li>
Third list item in E
</li>
</ul>
List of items in F
<ol>
<li>
First list item in F
</li>
<li>
Second list item in F
</li>
<li>
Third list item in F
</li>
</ol>
<p>
Text block 6.
</p>
<p>
Text block 7.
</p>
<h2>
Another Mid Header
</h2>
<p>
Text block 8.
</p>
<h2>
Another Mid Header in Another B
</h2>
<p>
Text block 9.
</p>
</td></tr></table>
</body></html>

Figure 4

    xsl:output ELEMENT_NODE
        Attribute: method=xml
        Attribute: doctype-public=-//W3C//DTD 
                       XHTML 1.0 Transitional//EN
        Attribute: doctype-system=http://www.w3.
        org/TR/xhtml1/DTD/xhtml1-transitional.dtd

Figure 5

<xsl:output method="xml" doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN" doctype-system="http://www.w3. org/TR/xhtml1/DTD/xhtml1-transitional.dtd" /> Listing 1

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 
     Transitional//EN" "http://www.w3.org/TR/
     xhtml1/DTD/xhtml1-transitional.dtd">

Figure 6

1. method
2. doctype-public
3. doctype-system

• Strict
• Transitional
• Frameset

    xsl:template ELEMENT_NODE
        Attribute: match=/
      html ELEMENT_NODE
        head ELEMENT_NODE
          meta ELEMENT_NODE
              Attribute: http-equiv=content-type
              Attribute: content=text/html; 
                                    charset=UTF-8
          title ELEMENT_NODE
            #text Generated XHTML file
        body ELEMENT_NODE
           table ELEMENT_NODE
              Attribute: border=2
              Attribute: cellspacing=0
              Attribute: cellpadding=0
              Attribute: width=330
              Attribute: bgcolor=#FFFF00
            tr ELEMENT_NODE
              td ELEMENT_NODE
                xsl:apply-templates ELEMENT_NODE

Figure 7

<xsl:template match="/"> <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"/> <title>Generated XHTML file</title> </head> <body> <table border="2" cellspacing="0" cellpadding="0" width="330" bgcolor="#FFFF00" > <tr> <td> <xsl:apply-templates/> </td> </tr> </table> </body> </html> </xsl:template> Listing 2

NOTE THAT IT WAS NECESSARY FOR ME TO MANUALLY
INSERT LINE BREAKS IN SEVERAL OF THE LONG LINES
IN THIS MATERIAL TO FORCE IT TO FIT INTO THIS
NARROW PUBLICATION FORMAT.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 
     Transitional//EN" "http://www.w3.org/TR/
     xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<meta http-equiv="content-type" 
     content="text/html; charset=UTF-8"/>
<title>Generated XHTML file</title>
</head>
<body>
<table border="2" cellspacing="0" cellpadding="0"
      width="330" bgcolor="#FFFF00"><tr><td>

...HTML CODE DELETED FOR BREVITY...

</td></tr></table>
</body></html>

Figure 8

    xsl:template ELEMENT_NODE
        Attribute: match=Q
      h1 ELEMENT_NODE
        xsl:apply-templates ELEMENT_NODE

Figure 9

<xsl:template match="Q"> <h1> <xsl:apply-templates /> </h1> </xsl:template> Listing 3

<h1>
A Big Header
</h1>

Figure 10

    xsl:template ELEMENT_NODE
        Attribute: match=B
      xsl:apply-templates ELEMENT_NODE

Figure 11

<xsl:template match="B"> <xsl:apply-templates /> </xsl:template> Listing 4

    B ELEMENT_NODE
      ...
      B ELEMENT_NODE
        ...
        B ELEMENT_NODE
          ...
          D ELEMENT_NODE
            E ELEMENT_NODE
              #text First list item in E
              G ELEMENT_NODE
                #text Nested G text element
            F ELEMENT_NODE
              #text First list item in F
            E ELEMENT_NODE
              #text Second list item in E
            F ELEMENT_NODE
              #text Second list item in F
            E ELEMENT_NODE
              #text Third list item in E
            F ELEMENT_NODE
              #text Third list item in F

Figure 12

    xsl:template ELEMENT_NODE
        Attribute: match=D
      #text List of items in E

      ul ELEMENT_NODE
        xsl:for-each ELEMENT_NODE
            Attribute: select=E
          li ELEMENT_NODE
            xsl:apply-templates ELEMENT_NODE
      #text List of items in F
      ol ELEMENT_NODE
        xsl:for-each ELEMENT_NODE
            Attribute: select=F
          li ELEMENT_NODE
            xsl:apply-templates ELEMENT_NODE

Figure 13

<xsl:template match="D">List of items in E <ul> <!-- loop --> <xsl:for-each select="E"> <li> <xsl:apply-templates /> </li> </xsl:for-each> <!-- End loop --> </ul>List of items in F <ol> <!-- loop --> <xsl:for-each select="F"> <li> <xsl:apply-templates /> </li> </xsl:for-each> <!-- End loop --> </ol> </xsl:template> Listing 5

NOTE: LITERAL TEXT AND COMMENTS WERE MANUALLY REMOVED FROM THIS TEMPLATE RULE FOR DISCUSSION PURPOSES. <xsl:template match="D"> <xsl:for-each select="E"> <xsl:apply-templates /> </xsl:for-each> <xsl:for-each select="F"> <xsl:apply-templates /> </xsl:for-each> </xsl:template> Listing 6

First list item in E

    xsl:template ELEMENT_NODE
        Attribute: match=G
      b ELEMENT_NODE
         xsl:apply-templates ELEMENT_NODE

Figure 14

<xsl:template match="G"> <b> <xsl:apply-templates /> </b> </xsl:template> Listing 7

Nested G text element

Second list item in E

Third list item in E

List of items in E
<ul>
<li>
First list item in E
<b>
Nested G text element
</b>
</li>
<li>
Second list item in E
</li>
<li>
Third list item in E
</li>
</ul>
List of items in F
<ol>
<li>
First list item in F
</li>
<li>
Second list item in F
</li>
<li>
Third list item in F
</li>
</ol>

Figure 15

• To iterate on child nodes named E,
• To extract the text values of those nodes and their descendants, and
• To embed those values in XHTML elements to cause the values to be rendered as an unordered list.

• To iterate on child nodes named F,
• To extract text values from those nodes, and
• To embed those values in XHTML elements to cause the values to be rendered an ordered list.

The Java Code Transformation

• Go to the processNode method.
• Identify the node type.
• Change the conditional clause in the if statement to implement the required match.
• Write code in the body of the if statement to implement the custom rule.

1. An XSLT style sheet and transformation, as discussed above.
2. Program code that emulates the behavior of the XSLT transformation.

1. The name of the input XML file - must be Dom03.xml.
2. The name of the output file to be produced by the XSLT transformation.
3. The name of the output file to be produced by the program code that emulates the XSLT transformation.

public class Dom03{ //Code deleted for brevity //In main method //Process the DOM tree thisObj.processDocumentNode(document); //Perform XSLT transformation thisObj.doXslTransform( document,argv[1],procInstr); //Exception handling code deleted for brevity }// end main() Listing 8

• Performs all the steps necessary to parse the input XML file, producing an object of type Document whose reference is saved in a reference variable named document.
• Instantiates an object of the Dom03 class and saves its reference in a reference variable named thisObj.
• Invokes the method named processDocumentNode on thisObj to transform the DOM tree to an output file using program code to perform the transformation.
• Invokes the method named doXslTransform on thisObj to perform an XSLT transformation using an XSL stylesheet.
  

void processDocumentNode(Node node){ //Create the beginning of the XHTML document out.println("<?xml version=\"1.0\" " + "encoding=\"UTF-8\"?>"); out.println( "<!DOCTYPE html PUBLIC \"-//W3C//DTD " + "XHTML 1.0 Transitional//EN\" " + "\"http://www.w3.org/TR/xhtml1/" + "DTD/xhtml1-transitional.dtd\">"); Listing 9

out.println("<html xmlns=\"http://www.w3." + "org/1999/xhtml\" xml:lang=\"en\"" + " lang=\"en\">"); out.println("<head>"); out.println( "<meta http-equiv=\"content-type\" " + "content=\"text/html; charset=" + "UTF-8\"/>"); out.println("<title>Generated XHTML file" + "</title>"); out.println("</head>"); out.println("<body>"); //Output similar to the above applies to // most XHTML documents. //Now set up an XHTML table. This is // peculiar to this particular example. out.println("<table border=\"2\" " + "cellspacing=\"0\" " + "cellpadding=\"0\" " + "width=\"330\" " + "bgcolor=\"#FFFF00\">" + "<tr><td>"); Listing 10

processNode(node); //Finish the XHTML table. This output is // peculiar to this particular example. out.println("</td></tr></table>"); //Now finish the output document and flush // the output buffer. This would apply to // most XHTML documents. out.println("</body></html>"); out.flush(); }//end processDocumentNode Listing 11

1. root or document node
2. element node
3. attribute node
4. text node
5. comment node
6. processing instruction node
7. namespace node
   

void processNode(Node node){ try{ if (node == null){ System.err.println( "Nothing to do, node is null"); return; }//end if //Get the actual type of the node int type = node.getNodeType(); Listing 12

switch (type){ case Node.DOCUMENT_NODE:{ if(false){ //unreachable in this program }else{//invoke default behavior defElOrRtNodeTemp(node); }//end else break; }//end case DOCUMENT_NODE Listing 13

• Go to this method named processNode.
• Identify the case for the node type in the switch statement.
• Change the conditional clause in the if statement for that case to implement a match for a particular node of that type.
• Write code in the body of the if statement to implement the custom template rule.

case Node.ELEMENT_NODE:{ if(node.getNodeName() == "B"){ applyTemplates(node,null); }//end if Listing 14

else if(node.getNodeName() == "C"){ out.println("<p>"); applyTemplates(node,null); out.println("</p>"); }//end if Listing 15

else if(node.getNodeName() == "D"){ out.println("List of items in E"); out.println("<ul>"); forEach(node,"E"); out.println("</ul>"); out.println("List of items in F"); out.println("<ol>"); forEach(node,"F"); out.println("</ol>"); }//end if Listing 16

private void forEach(Node node,String select){ NodeList children = node.getChildNodes(); if (children != null){ int len = children.getLength(); //Iterate on NodeList of child nodes, // processing nodes that match the select. for (int i = 0; i < len; i++){ if(children.item(i).getNodeName(). equals(select)){ //Make a recursive call from within // this iterative template rule. processNode(children.item(i)); }//end if }//end for loop }//end if }//end forEach Listing 17

• A reference to a particular node of type Node.
• The name of a node that should be a child node of the node.

else if(node.getNodeName() == "E"){ out.println("<li>"); applyTemplates(node,null); out.println("</li>"); }//end if Listing 18

else if(node.getNodeName() == "F"){ out.println("<li>"); applyTemplates(node,null); out.println("</li>"); }//end if Listing 19

else if(node.getNodeName() == "G"){ out.println("<b>"); applyTemplates(node,null); out.println("</b>"); }//end if Listing 20

//Create four levels of XHTML headers else if(node.getNodeName() == "Q"){ out.println("<h1>"); applyTemplates(node,null); out.println("</h1>"); }//end if else if(node.getNodeName() == "R"){ out.println("<h2>"); applyTemplates(node,null); out.println("</h2>"); }//end if else if(node.getNodeName() == "S"){ out.println("<h3>"); applyTemplates(node,null); out.println("</h3>"); }//end if else if(node.getNodeName() == "T"){ out.println("<h4>"); applyTemplates(node,null); out.println("</h4>"); }//end if Listing 21

else{//invoke default behavior defElOrRtNodeTemp(node); }//end else break; }//end case ELEMENT_NODE Listing 22

• Text nodes
• Attribute nodes
• Comment nodes
• Processing instruction nodes
• Namespace nodes (default case)
  

• main
• defTextOrArrrTemp
• defElOrRtNodeTemp
• defComOrProcInstrTemp
• applyTemplates
• valueOf
• doXslTransform

I encourage you to copy the Java code, XML file, and XSL file from the listings near the end of this lesson.  Compile and execute the program.  Experiment with the files, making changes, and observing the results of your changes.

Summary

What's Next?

The next several lessons in this series will illustrate parallel Java code and XSLT transformations to transform XML documents into XHTML documents.  The sample programs will illustrate various aspects of the manipulation of a DOM tree using Java code.

/*File Dom03.java Copyright 2003 R.G.Baldwin Ths program transforms an XML file into an XHTML file using a combination of recursive and iterative processing. New material added to this lesson includes a method that emulates an xsl:for-each template rule. This program compares the transformation of an XML file to an XHTML file using two different approaches: 1. An XSLT style sheet 2. Program code that emulates the behavior of the XSL transformation. Two XHTML files are produced, one by the XSL transformation and one by the program code. Both output files validate as XHTML at http://validator.w3.org/file-upload.html Both also validate as HTML at http://www.htmlhelp.com/tools/validator/ upload.html Both also validate using the program named DomTree02.java,which means that they validate as XML under JAXP. The program requires three command line parameters in the following order: 1, The name of the input XML file - must be Dom03.xml 2. The name of the XHTML output file to be produced by the XSL transformation. 3. The name of the XHTML output file to be produced by the program code that emulates the XSL transformation. This program implements all six built-in default template rules for an XML processor. In addition, it implements several other template rules that are required to support the built in rules, such as xsl:value-of and xsl:for-each. The program creates several custom template rules. To create a custom temtlate rule: 1. Go to the processNode method. 2. Identify the node type. 3. Change the conditional clause in the if statement to implement the match. 4. Write code in the body of the if statement to implement the custom rule. If the modified conditional clause evaluates to true, the custom rule will be executed. If false,the default rule will be executed. In particular, this program illustrates Java code that emulates the XSLT templates in the file named Dom03.xsl. The name of the XSL stylesheet file is extracted from the processing instruction in the XML file. The program begins by executing code to transform the incoming XML file in a way that mimics the XSL Transformation. Along the way, it saves the processing instructions containing the ID of the stylesheet file for use by the XSLT process later. Otherwise, the code that performs the XSL transformation later would have to search the DOM tree for the XSL stylesheet file. Then the program uses the XSLT style sheet to transform the XML file into a result file. This is not a general purpose program. This program, and the XSLT file named Dom03.xsl are specifically designed to transform the contents of the file named Dom03.xml into an XHTML file. No effort was made to provide meaningful information about errors and exceptions. Tested with SDK 1.4.2 under WinXP. ************************************************/ import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.DocumentBuilder; import org.w3c.dom.*; import javax.xml.transform.Transformer; import javax.xml.transform.TransformerFactory; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.*; import java.util.*; import java.io.*; public class Dom03{ PrintWriter out;//output stream //Save processing instruction nodes here static Vector procInstr = new Vector(); public static void main(String argv[]){ if (argv.length != 3){ System.err.println( "usage: java Dom03 " + "xmlFileIn " + "xformFileOut " + "codeFileOut"); System.exit(0); }//end if try{ //Get a factory object for DocumentBuilder // objects /// DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); //Configure the factory object. Change // the following parameter to false for a // non-validating parser. /// factory.setValidating(true); factory.setNamespaceAware(false); //The following statement causes the parser // to ignore cosmetic whitespace between // elements. /// factory. setIgnoringElementContentWhitespace(true); //Get a DocumentBuilder (parser) object /// DocumentBuilder builder = factory.newDocumentBuilder(); //Parse the XML input file to create a // Document object that represents the // input XML file. /// Document document = builder.parse( new File(argv[0])); //Instantiate an object of this class /// Dom03 thisObj = new Dom03(); //TRANSFORMATION THROUGH PROGRAM CODE //Use program code to transform the // DOM tree into an output file. // //Get an output stream for the output // produced by the program code. This // stream object is used by several // methods, so it was instantiated at this // point and saved as an instance variable // of the object. /// thisObj.out = new PrintWriter( new FileOutputStream(argv[2])); //Process the DOM tree, beginning with the // Document node to produce the output. // Invocation of processDocumentNode starts // a recursive process that processes the // entire DOM tree. /// thisObj.processDocumentNode(document); //XSLT TRANSFORMATION //Use XSLT to transform the DOM tree into // an output file. Note that the success // of this method call depends on the // stylesheet processing instruction having // been saved while the transformation was // being performed using program code // above. Otherwise, it would be necessary // to include the code in this method to // search the DOM tree for the stylesheet // processing instruction. All processing // instructions are saved in a Vector // object, which is passed as the third // parameter to this method. /// thisObj.doXslTransform( document,argv[1],procInstr); }catch(Exception e){ //Note that no effort was made to provide // meaningful results in the event of an // exception or error. /// e.printStackTrace(System.err); }//end catch }// end main() //-------------------------------------------// //This method is used to produce any text // required in the output at the document // level, such as the XML declaration for an // XML document. void processDocumentNode(Node node){ //Create the beginning of the XHTML document out.println("<?xml version=\"1.0\" " + "encoding=\"UTF-8\"?>"); out.println( "<!DOCTYPE html PUBLIC \"-//W3C//DTD " + "XHTML 1.0 Transitional//EN\" " + "\"http://www.w3.org/TR/xhtml1/" + "DTD/xhtml1-transitional.dtd\">"); out.println("<html xmlns=\"http://www.w3." + "org/1999/xhtml\" xml:lang=\"en\"" + " lang=\"en\">"); out.println("<head>"); out.println( "<meta http-equiv=\"content-type\" " + "content=\"text/html; charset=" + "UTF-8\"/>"); out.println("<title>Generated XHTML file" + "</title>"); out.println("</head>"); out.println("<body>"); //Output similar to the above applies to // most XHTML documents. //Now set up an XHTML table. This is // peculiar to this particular example. out.println("<table border=\"2\" " + "cellspacing=\"0\" " + "cellpadding=\"0\" " + "width=\"330\" " + "bgcolor=\"#FFFF00\">" + "<tr><td>"); //Go process the root (document) node. This // method call triggers a recursive process // that processes the entire DOM tree. processNode(node); //Finish the XHTML table. This output is // peculiar to this particular example. out.println("</td></tr></table>"); //Now finish the output document and flush // the output buffer. This would apply to // most XHTML documents. out.println("</body></html>"); out.flush(); }//end processDocumentNode //-------------------------------------------// //There are seven kinds of nodes: // root or document // element // attribute // text // comment // processing instruction // namespace // //This method handles the first six. // Apparently it is not possible to handle // namespace nodes in Java because there is // no constant in the Node class to identify // namespace nodes /// void processNode(Node node){ try{ if (node == null){ System.err.println( "Nothing to do, node is null"); return; }//end if //Process the incoming node based on its // type. /// int type = node.getNodeType(); //To define an overriding template rule, // insert the matching condition in the // conditional clause of the if statement, // and provide code to implement the rule // in the body of the if statement. If the // conditional clause evaluates to true, // the default rule for that element type // will not be processed. /// switch (type){ case Node.TEXT_NODE:{ if(true){ out.println(node.getNodeValue()); }else{//invoke default behavior //This won't be reached in this // example, but I will leave it // here as a reminder of the // default behavior. out.print(defTextOrAttrTemp(node)); }//end else break; }//end case Node.TEXT_NODE case Node.ATTRIBUTE_NODE:{ if(false){ //Change conditional and write // overriding handler here /// }else{//invoke default behavior out.print(defTextOrAttrTemp(node)); }//end else break; }//end case Node.ATTRIBUTE_NODE case Node.ELEMENT_NODE:{ if(node.getNodeName() == "B"){ //Process all XML child nodes // recursively applyTemplates(node,null); }//end if else if(node.getNodeName() == "C"){ //Begin XHTML paragraph element out.println("<p>"); //Process all XML child nodes // recursively applyTemplates(node,null); //End XHTML paragraph element out.println("</p>"); }//end if else if(node.getNodeName() == "D"){ //First process the child nodes // named E. out.println("List of items in E"); //Begin XHTML unordered list out.println("<ul>"); //Iteratively put text from E // elements and their children into // the list. forEach(node,"E"); //End XHTML unordered list out.println("</ul>"); //Now process the child nodes // named F. out.println("List of items in F"); //Begin XHTML ordered list out.println("<ol>"); //Iteratively put text from F // elements and their children in the // list. forEach(node,"F"); //End XHTML ordered list out.println("</ol>"); }//end if else if(node.getNodeName() == "G"){ //Display children as XHTML bold out.println("<b>"); applyTemplates(node,null); out.println("</b>"); }//end if //Create four levels of XHTML headers else if(node.getNodeName() == "Q"){ out.println("<h1>"); applyTemplates(node,null); out.println("</h1>"); }//end if else if(node.getNodeName() == "R"){ out.println("<h2>"); applyTemplates(node,null); out.println("</h2>"); }//end if else if(node.getNodeName() == "S"){ out.println("<h3>"); applyTemplates(node,null); out.println("</h3>"); }//end if else if(node.getNodeName() == "T"){ out.println("<h4>"); applyTemplates(node,null); out.println("</h4>"); }//end if //The following rules for E and F // are invoked as a result of the // behavior of the forEach method. The // code could have been placed inside // the forEach method. However, I // elected to put it here in an attempt // to confine all of the custom code // to the methods named processNode and // processDocumentNode. else if(node.getNodeName() == "E"){ //Create an XHTML list item // containing information from child // nodes. out.println("<li>"); applyTemplates(node,null); out.println("</li>"); }//end if else if(node.getNodeName() == "F"){ //Create an XHTML list item // containing information from child // nodes. out.println("<li>"); applyTemplates(node,null); out.println("</li>"); }//end if else{//invoke default behavior defElOrRtNodeTemp(node); }//end else break; }//end case ELEMENT_NODE case Node.DOCUMENT_NODE:{ if(false){ //Change conditional and write // overriding handler here /// }else{//invoke default behavior defElOrRtNodeTemp(node); }//end else break; }//end case DOCUMENT_NODE case Node.COMMENT_NODE:{ if(false){ //Change conditional and write // overriding handler here /// }else{//invoke default behavior defComOrProcInstrTemp(node); }//end else break; }//end case COMMENT_NODE case Node.PROCESSING_INSTRUCTION_NODE:{ if(false){ //Change conditional and write // overriding handler here }else{//invoke default behavior //First save proc instr for later // use. procInstr.add(node); //Now invoke default behavior. defComOrProcInstrTemp(node); }//end else break; }//end case PROCESSING_INSTRUCTION_NODE default:{ //Ignore all other node types. }//end default }//end switch }catch(Exception e){ e.printStackTrace(System.err); }//end catch }//end processNode(Node) //-------------------------------------------// //This method emulates the following default // template rule: // <xsl:template match="text()|@*"> // <xsl:value-of select="."/> // </xsl:template> /// String defTextOrAttrTemp(Node node) throws Exception{ int nodeType = node.getNodeType(); if((nodeType == Node.ATTRIBUTE_NODE) || (nodeType == Node.TEXT_NODE)){ //Get and return the value of the context // node. /// return valueOf(node,"."); }else{ throw new Exception( "Bad call to defaultTextOrAttr method"); }//end else }//end defaultTextOrAttr //-------------------------------------------// //This method emulates the following default // template rule: // <xsl:template match="*|/"> // <xsl:apply-templates/> // </xsl:template> /// void defElOrRtNodeTemp(Node node) throws Exception{ int nodeType = node.getNodeType(); if((nodeType == Node.ELEMENT_NODE) || (nodeType == Node.DOCUMENT_NODE)){ //Note that the following is a recursive // method call. /// applyTemplates(node,null); }else{ throw new Exception( "Bad call to defElOrRtNodeTemp"); }//end else }//end defElOrRtNodeTemp //-------------------------------------------// //This method emulates the following default // template rule: // <xsl:template // match="processing-instruction()|comment()" /// String defComOrProcInstrTemp(Node node) throws Exception{ int nodeType = node.getNodeType(); if((nodeType == Node.COMMENT_NODE) || (nodeType == Node.PROCESSING_INSTRUCTION_NODE)){ //According to page Nutshell pg 148, the // default rule for comments and processing // instructions doesn't output anything // into the result tree. /// return "";//empty string }else{ throw new Exception("Bad call to " + "defalutCommentOrProcInstrTemplate"); }//end else }//end defComOrProcInstrTemp //-------------------------------------------// //See Nutshell, pg 148 for an explanation as to // why it is not possible to write a Java // method that emulates the default namespace // template. /// void defaultNamespaceTemplate(Node node) throws Exception{ throw new Exception("See Nutshell pg 148" + "regarding default behavior for " + "namespace template."); }//end defaultNamespaceTemplate //-------------------------------------------// //Simulates an XSLT apply-templates rule. // <xsl:apply-templates // optional select = "..." // optional mode = "..." // > //Note that the mode attribute is not supported // in this version. //If the select parameter is null, all child // nodes are processed. void applyTemplates(Node node,String select){ NodeList children = node.getChildNodes(); if (children != null){ int len = children.getLength(); //Iterate on NodeList of child nodes. for (int i = 0; i < len; i++){ if((select == null) || (select.equals(children.item(i). getNodeName()))){ //Note that the following is a // recursive method call. /// processNode(children.item(i)); }//end if }//end for loop }//end if children != null }//end applyTemplates //-------------------------------------------// //This method simulates an XSLT // <xsl:value-of select="???"/> // The general form of the method call is // valueOf(Node theNode,String select) // //The method recognizes three forms of call: // valueOf(Node theNode,String "@attrName") // valueOf(Node theNode,String ".") // valueOf(Node theNode,String "nodeName") // //In the first form, the method returns the // text value of the named attribute of // theNode. An attribute is specified by a // select value that begins with @. If the // attribte doesn't exist, the method returns // an empty string. // //In the second form, the method returns the // concatenated text values of descendants of // the context node. // //In the third form, the method returns the // concatenated text values of all descendants // of a specified child node of the context // node. If the context node has more than one // child node with the specified name, only the // first one found is processed. The others // are ignored. // //The method does not support the following, // which are standard features of xsl:value-of: // disable-output-escaping // processing instruction nodes // comment nodes // namespace nodes /// public String valueOf(Node node,String select){ if(select != null && select.charAt(0) == '@'){ //This is a request for the value of an // attribute. Returns empty string if the // attribute doesn't exist on the element. String attrName = select.substring(1); NamedNodeMap attrList = node.getAttributes(); Node attrNode = attrList.getNamedItem( attrName); if(attrNode != null){ return attrNode.getNodeValue(); }else{ return "";//empty string }//end else }//end if on @ else if(select != null && select.equals(".")){ //This is a request to process the context // node int nodeType = node.getNodeType(); if(nodeType == Node.ELEMENT_NODE){ //Process the context node as an element // node. Return the concatenated text // values of all descendants of the // context node. NodeList childNodes = node.getChildNodes(); int listLen = childNodes.getLength(); String nodeTextValue = "";//result for(int j = 0; j < listLen; j++){ nodeTextValue += valueOf(childNodes.item(j),"."); }//end for loop return nodeTextValue; }else if(nodeType == Node.TEXT_NODE){ //Process the context node as a text // node. Simply get and return its // value. return node.getNodeValue(); }else{ //ignore all other context node types }//end else }//end if for context node else if(select != null){ //Process a child node whose name is // specified by the value of the incoming // parameter named select. Get and return // the concatenated text values of all // descendants of the specified child node. //This process assumes that there is only // one child node with the specified name // and processes the first one that it // finds. NodeList children = node.getChildNodes(); int len = children.getLength(); for (int i = 0; i < len; i++){ //Trap the specified child node if(children.item(i).getNodeName(). equals(select)){ //Make a recursive call and let // existing code do the work. return valueOf(children.item(i),"."); //The above return statement causes any // additional child nodes having the // same name to be ignored. }//end if getNodeName == select }//end for loop on all child nodes }//end else if(select != null) //Will reach here only if value of select // is null. /// return "";//empty string }//end method valueOf //-------------------------------------------// //This method simulates an XSLT for-each // template rule private void forEach(Node node,String select){ NodeList children = node.getChildNodes(); if (children != null){ int len = children.getLength(); //Iterate on NodeList of child nodes, // processing nodes that match the select. for (int i = 0; i < len; i++){ if(children.item(i).getNodeName(). equals(select)){ //Make a recursive call from within // this iterative template rule. processNode(children.item(i)); }//end if }//end for loop }//end if }//end forEach //-------------------------------------------// //This method uses an incoming XSLT stylesheet // file to transform an incoming Document // object into an output file. Note that the // successful invocation of this method depends // on the processing instruction containing the // stylesheet having been saved in a Vector // object that is received as an incoming // parameter. Otherwise, this method would // have to search the DOM for the stylesheet // processing instruction. /// void doXslTransform(Document document, String outFile, Vector procInstr) throws Exception{ try{ //Get stylesheet ID from proc instr. ProcessingInstruction pi = null; boolean piFlag = false; int size = procInstr.size(); //Search for a stylesheet in the Vector // containing processing instruction nodes. /// for(int i = 0; i < size; i++){ pi = (ProcessingInstruction)procInstr. get(i); if(pi.getTarget().startsWith( "xml-stylesheet") && pi.getData(). startsWith("type=\"text/xsl\"")){ //Looks like a good stylesheet. /// piFlag = true; break; }//end if }//end for loop if(piFlag == false){//still false? throw new Exception( "No valid stylesheet"); }//end if //Get the stylesheet file reference /// String xslFile = pi.getData(). substring(pi.getData().indexOf( "href=")+6); //Eliminate the quotation mark at the end /// xslFile = xslFile.substring( 0,xslFile.length()-1); //Get a TransformerFactory object /// TransformerFactory xformFactory = TransformerFactory.newInstance(); //Get an XSL Transformer object based on // the XSL file discovered above. /// Transformer transformer = xformFactory.newTransformer( new StreamSource( new File(xslFile))); //Get a DOMSource object that represents // the DOM tree. /// DOMSource source = new DOMSource(document); //Get an output stream for the output // file. /// PrintWriter xformStream = new PrintWriter( new FileOutputStream(outFile)); //Get a StreamResult object that points to // the output file. Then transform the DOM // sending text to the output file. /// StreamResult xformResult = new StreamResult(xformStream); //Do the transform /// transformer.transform(source,xformResult); }catch(Exception e){ e.printStackTrace(System.err); }//end catch }//end doXslTransform }// class Dom03 Listing 23

NOTE: IT WAS NECESSARY TO MANUALLY ENTER SOME LINE BREAKS INTO THIS DOCUMENT TO FORCE IT TO FIT INTO THE NARROW PUBLICATION FORMAT. <?xml version="1.0"?> <!-- File Dom03.xml Copyright 2003 R. G. Baldwin Illustrates recursive and iterative transformation using templates and for-each.--> <!DOCTYPE A [ <!ELEMENT A (Q,B,B)*> <!ELEMENT B (B | C | D | R | S | T)*> <!ELEMENT C (#PCDATA)> <!ELEMENT D (E | F)*> <!ELEMENT E (#PCDATA | G)*> <!ELEMENT F (#PCDATA)> <!ELEMENT G (#PCDATA)> <!ELEMENT Q (#PCDATA)> <!ELEMENT R (#PCDATA)> <!ELEMENT S (#PCDATA)> <!ELEMENT T (#PCDATA)> ]> <?xml-stylesheet type="text/xsl" href="Dom03.xsl"?> <A> <Q>A Big Header</Q> <B> <C>Text block 1.</C> <R>A Mid Header</R> <C>Text block 2.</C> <!--Following PI should be ignored by both the XSLT and the coded processor.--> <?processor ProcInstr="Dummy"?> <S>A Small Header</S> <B> <C>Text block 3.</C> </B> <S>Another Small Header</S> <B> <C>Text block 4.</C> <T>A Smallest Header</T> <B> <C>Text block 5.</C> <D> <E>First list item in E <G>Nested G text element</G> </E> <F>First list item in F</F> <E>Second list item in E</E> <F>Second list item in F</F> <E>Third list item in E</E> <F>Third list item in F</F> </D> <C>Text block 6.</C> </B> <C>Text block 7.</C> </B> <R>Another Mid Header</R> <C>Text block 8.</C> </B> <B> <R>Another Mid Header in Another B</R> <C>Text block 9.</C> </B> </A> Listing 24

NOTE: IT WAS NECESSARY TO MANUALLY ENTER SOME LINE BREAKS INTO THIS DOCUMENT TO FORCE IT TO FIT INTO THE NARROW PUBLICATION FORMAT. <?xml version='1.0'?> <!-- File Dom03.xsl Copyright 2003 R. G. Baldwin Illustrates recursive and iterative transformation using templates and for-each.--> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999 /XSL/Transform" > <xsl:output method="xml" doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN" doctype-system="http://www.w3. org/TR/xhtml1/DTD/xhtml1-transitional.dtd" /> <!--Match the root of the DOM tree--> <xsl:template match="/"> <!--Note, would like to see the following attribute on the html tag, but it causes problems with the JAXP transformer. xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> --> <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"/> <title>Generated XHTML file</title> </head> <body> <table border="2" cellspacing="0" cellpadding="0" width="330" bgcolor="#FFFF00" > <tr> <td> <!--Process children of DOM root--> <xsl:apply-templates/> </td> </tr> </table> </body> </html> </xsl:template> <!-- End root match template --> <xsl:template match="B"> <xsl:apply-templates /> </xsl:template> <!-- End B match template --> <xsl:template match="C"> <p> <xsl:apply-templates /> </p> </xsl:template> <!-- End C match template --> <xsl:template match="D">List of items in E <ul> <!-- loop --> <xsl:for-each select="E"> <li> <xsl:apply-templates /> </li> </xsl:for-each> <!-- End loop --> </ul>List of items in F <ol> <!-- loop --> <xsl:for-each select="F"> <li> <xsl:apply-templates /> </li> </xsl:for-each> <!-- End loop --> </ol> </xsl:template> <!-- End D match template --> <xsl:template match="G"> <b> <xsl:apply-templates /> </b> </xsl:template> <!-- End G match template --> <!-- Header templates follow --> <xsl:template match="Q"> <h1> <xsl:apply-templates /> </h1> </xsl:template> <!-- End Q match template --> <xsl:template match="R"> <h2> <xsl:apply-templates /> </h2> </xsl:template> <!-- End R match template --> <xsl:template match="S"> <h3> <xsl:apply-templates /> </h3> </xsl:template> <!-- End S match template --> <xsl:template match="T"> <h4> <xsl:apply-templates /> </h4> </xsl:template> <!-- End T match template --> </xsl:stylesheet> Listing 25

Copyright 2004, Richard G. Baldwin.  Reproduction in whole or in part in any form or medium without express written permission from Richard Baldwin is prohibited.

About the author

Richard has participated in numerous consulting projects, and he frequently provides onsite training at the high-tech companies located in and around Austin, Texas.  He is the author of Baldwin's Programming Tutorials, which has gained a worldwide following among experienced and aspiring programmers. He has also published articles in JavaPro magazine.

Richard holds an MSEE degree from Southern Methodist University and has many years of experience in the application of computer technology to real-world problems.

Baldwin@DickBaldwin.com

-end-