Java JAXP, Implementing Default XSLT Behavior in Java

Baldwin explains default XSLT behavior, and shows you how to write Java code that mimics that behavior.  The resulting Java code serves as a skeleton for more advanced transformation programs.

Published:  February 17, 2004
By Richard G. Baldwin

Java Programming Notes # 2206

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

In this lesson, I will explain default XSLT behavior, and will show you how to write Java code that mimics that behavior.  The resulting Java code serves as a skeleton for more advanced transformation programs.

What is JAXP?

JAXP is an API designed to help you write programs for creating and processing XML documents.  JAXP is very important for many reasons, not the least of which is the fact that it is a critical part of Sun's Java Web Services Developer Pack (JWSDP).  As you are probably already aware, web services is expected by many to be a very important aspect of the Internet of the future

This lesson is one in a series designed to help you understand how to use JAXP and how to use the JWSDP.

The first lesson in this series was entitled Java API for XML Processing (JAXP), Getting Started.  The previous lesson was entitled Java JAXP, Exposing a DOM Tree.

What is XML?

• 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.  Document and its superinterface Node declare numerous methods that can be used to navigate, extract information from, modify, and otherwise manipulate the DOM tree.  As is always the case, classes that implement Document must provide concrete definitions of those methods.

Many operations are possible

Given an object of type Document, there are many methods that can be invoked on the object to perform a variety of operations.  For example, it is possible to write Java code to move nodes from one location in the tree to another location in the tree, thus rearranging the structure of the XML document represented by the Document object.  It is possible to delete nodes, and to insert new nodes.  It is also possible to recursively traverse the tree, extracting information about the nodes along the way.

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 and perform the transformation.
• By using XSLT to perform the transformation.

It should be possible to write Java code to perform any transformation that can be performed using XSLT, but the reverse may not be true.

General description of XSLT

Here is a partial quotation from XML In A Nutshell, (which I highly recommend), by Elliotte Rusty Harold and W. Scott Means.  This quotation provides a general description of XSLT:

"... (XSLT) is a functional programming language used to specify how an input XML document is converted into another text document -- possibly, though not necessarily, another XML document.  An XSLT processor reads both an input XML document and an XSLT stylesheet (which is itself an XML document because XSLT is an XML application) and produces a result tree as output. ... Documents can be transformed using a standalone program or as part of a larger program that communicates with the XSLT processor through its API."

In this lesson, I will provide and explain a larger program that communicates with the XSLT processor through its API.  The program will also execute Java code that mimics the transformation provided by XSLT.

Advantages and disadvantages

As is usually the case, there are advantages and disadvantages to both approaches to document transformation.

As an example of an advantage provided by XSLT, if it is possible to perform the required transformation using XSLT, that approach will probably require you to write less code than would be required to perform the same transformation by writing a Java program from scratch.

A large library of functions

With the XSLT transformation process, you write a stylesheet, which is somewhat analogous to a driver program in a more conventional programming environment.  That driver program accesses and uses functions from a large library of pre-written functions to perform a series of well-defined operations on the DOM tree to produce the desired transformation.

(XSLT authors don't call them functions.  Rather, they are called XSLT elements.  According to XML In A Nutshell, there are 37 standard XSLT elements.  Also according to XML In A Nutshell, most XSLT processors also provide various nonstandard extension elements and allow you to write your own extension elements in languages such as Java.)

Is there a similar library of Java methods?

I am not aware of a library of Java methods in the public domain that emulates the 37 standard XSLT Elements.  However, I freely admit that such a library may exist and I may simply not know about it.

Therefore, to write a Java program that emulates an XSLT transformation, you need to either

• Create your own library of Java methods and use that library with your Java code to perform the transformation, or
• Start from scratch each time and write a custom program to perform the transformation.

A skeleton library of Java methods

This lesson, and several lessons to follow this one, will 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 simply of writing a short driver program to access and use those methods.  Thus, given the proper library of methods, it is no more difficult to write a driver 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.

If you already know a lot about XSLT, you may learn a little about Java by studying these lessons.  If you already know a lot about Java, you may learn a little about XSLT.  If you don't already know either Java or XSLT, you may learn a little about both.

Debugging XSLT can be difficult

While writing a Java program to emulate an XSLT Transformation may require you to write more code than writing a stylesheet, in my opinion, it is much easier to debug a Java program that fails to deliver the desired result than it is to debug an XSL stylesheet that fails to deliver.  This is an advantage of using Java code over XSLT.  I find XSLT to be extremely difficult to debug (but I haven't attempted to use a fancy XSLT debugger, several of which are freely available on the Internet).

Java provides more detailed control

Another difference in using Java code relative to XSLT has to do with the detailed control of the transformation process.  I believe, (but cannot prove), that it is possible to write Java programs to provide transformations that are not possible using standard XSLT elements.  If I am correct, this may be another advantage of writing Java code over using XSLT.

Some Details Regarding XSLT

The following is a partial quotation from XML In A Nutshell.  (Note that I will be referring to this excellent book several more times in this lesson.  For brevity, I will refer to it simply as Nutshell.)

"XSLT is an XML application for specifying rules by which one XML document is transformed into another XML document.  An XSLT document -- that is, an XSLT stylesheet -- contains template rules.  Each template rule has a pattern and a template.  An XSLT processor compares the elements and other nodes in an input XML document to the template-rule patterns in a stylesheet.  When one matches, it writes the template from that rule into the output tree.  ... XSLT uses the XPath syntax to identify matching nodes."

My explanation

Let's see if I can explain this process in my own words.  Assume that an XML document has been parsed so as to produce a DOM tree in memory that represents the XML document.  (The creation of a DOM tree in this manner was discussed in several previous lessons in this series.)

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 what to do with each node that it encounters along the way.

Finding matching template rules

As each node is encountered, the processor searches the stylesheet looking for instructions on how to treat that node.  (These instructions will be referred to later as template rules.)  If the processor finds instructions that match the node type, it performs the operations indicated by the instructions.  If it doesn't find matching instructions, it executes built-in instructions appropriate to that node.

(An XML document can contain seven different types of nodes.  The different types will be identified later.  This lesson will describe and explain the built-in instructions for six of those seven node types.  Java code will be developed that emulates the built-in instructions for each of the six types of nodes.)

Establishing the context node

An XPath expression can be used to point to a specific node and to establish that node as the context node.  Once a context node is established, there are at least two XSLT elements that can be used to manage the traversal among children of that node:

• xsl:apply-templates
    select, optional attribute
    mode, optional attribute
    xsl:sort, optional XSLT element
  
• xsl:for-each
    select, required attribute
    xsl:sort, optional XSLT element
  

The xsl:apply-templates XSLT element

The first of these, xsl:apply-templates, examines and processes all child nodes of the context node that match an optional select attribute.

(When combined with a default template rule to be discussed later, this often results in a recursive examination and processing of all descendant nodes of the context node.)

According to Nutshell,

"The xsl:apply-templates instruction tells the processor to search for and apply the highest-priority template in the stylesheet that matches each node identified by the select attribute."

Applying template rules

As each node is examined, the processor searches the stylesheet to determine if the XSLT programmer has provided a template rule that matches the node and defines how that node should be treated.  If a matching template rule is found, the node is treated in the manner prescribed by the template rule.

Literal text in the XSLT stylesheet elements

You can think of the XSLT process as operating on an input DOM tree to produce an output DOM tree.  If the template rule being applied contains literal text, that literal text is used to create a text node in the output tree.

(I will explain how this feature is used to transform XML documents into XHTML documents in a future lesson.)

If no match is found

If a matching template rule is not found, the processor executes a built-in template rule appropriate to the type of node involved.  Built-in template rules are provided by the XSLT processor to handle the seven different types of nodes in an XML document:

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

This lesson will explain the built-in rules that handle the first six types of nodes in the above list.

Recursion is common

As mentioned earlier, the combination of xsl:apply-templates and a built-in template rule often produces recursion.  Assuming that there is nothing in a matching template rule that stops the recursion operation, recursion continues until all descendant nodes of the original context node have been examined and processed.

The mode attribute

The mode attribute of xsl:apply-templates makes it possible to cause different template rules to match nodes of the same type at different places in the DOM tree.

Sorting

The optional xsl:sort element makes it possible to modify the order in which the nodes are examined.

Iterative operation

The second XSLT element in the above list, xsl:for-each, executes an iterative examination and processing of all child nodes of the context node that match the required select attribute.  According to Nutshell,

"The xsl:for-each instruction iterates over the nodes identified by its select attribute and applies templates to each one."

In other words, the processor will examine all child nodes of the context node that match the select attribute.  As each child node is examined, the processor will search the stylesheet looking for a template rule that matches the child node.  If a matching template rule is found, the matching template rule will be used to process that node.  If a matching template rule is not found, a built-in template rule appropriate for the type of node will be used to process the node.

As before, the optional xsl:sort element makes it possible to modify the order in which the nodes are examined.  I will explain this in detail in a future lesson.

Combined operations

Frequently a stylesheet will combine recursive and iterative operations to produce more complex operations.

Enough talk, let's see some code

I will begin by discussing the XML file named Dom11.xml (shown in Listing 29) along with the XSL stylesheet file named Dom11.xsl (shown in Listing 30).  These two listings are provided near the end of the lesson.

After explaining the transformation produced by applying this stylesheet to this XML document, I will explain the transformation produced by applying the empty stylesheet named Dom11a.xsl, (shown in Listing 33), to a nearly identical XML document.

#document DOCUMENT_NODE
  top DOCUMENT_TYPE_NODE
  #comment COMMENT_NODE
  #comment COMMENT_NODE
  dummy-target PROCESSING_INSTRUCTION_NODE
  xml-stylesheet PROCESSING_INSTRUCTION_NODE
  false-target PROCESSING_INSTRUCTION_NODE
  top ELEMENT_NODE
    theData ELEMENT_NODE
        Attribute: attr=Dummy Attr Value
      title ELEMENT_NODE
        #text Java

        subtitle ELEMENT_NODE
            Attribute: position=Low
          #text really
        #text rules

      author ELEMENT_NODE
        #text R.Baldwin
      price ELEMENT_NODE
        #text $9.95
    theData ELEMENT_NODE
      title ELEMENT_NODE
        #text Python
      author ELEMENT_NODE
        #text R.Baldwin
      price ELEMENT_NODE
        #text $15.42
    theData ELEMENT_NODE
      title ELEMENT_NODE
        #text XML
      author ELEMENT_NODE
        #text R.Baldwin
      price ELEMENT_NODE
        #text $19.60

Figure 1

#document DOCUMENT_NODE
  xsl:stylesheet ELEMENT_NODE
      Attribute: xmlns:xsl=http:
                 //www.w3.org/1999/XSL/Transform
      Attribute: version=1.0

    xsl:template ELEMENT_NODE
        Attribute: match=*|/
      xsl:apply-templates ELEMENT_NODE

    xsl:template ELEMENT_NODE
        Attribute: match=text()|@*
      xsl:value-of ELEMENT_NODE
          Attribute: select=.

Figure 2

<xsl:template match="*|/"> <xsl:apply-templates/> </xsl:template> Listing 1

<xsl:template match="text()|@*"> <xsl:value-of select="."/> </xsl:template> Listing 2

<?xml version="1.0" encoding="UTF-8"?>
Java
reallyrules
R.Baldwin$9.95PythonR.Baldwin$15.42XMLR.Baldwin
$19.60

Figure 3

<title>Java <subtitle position="Low">really</subtitle>rules </title> Listing 3

#document DOCUMENT_NODE
  xsl:stylesheet ELEMENT_NODE
      Attribute: xmlns:xsl=http:
                 //www.w3.org/1999/XSL/Transform
      Attribute: version=1.0

Figure 4

• root node
• element node
• attribute node
• text node

• comment node
• processing instruction node

• Demonstrate Java code that replicates the behavior of the built-in template rules for six of the seven possible types of nodes.
• Provide a skeleton program that can be expanded later to provide more complex behavior.

• An XSLT transformation operating under program control.
• Program code that emulates the behavior of the XSLT transformation.

• The name of the input XML file - must be Dom11.xml or Dom11a.xml.
• The name of the output file to be produced by the XSLT transformation.
• The name of the output file to be produced by the program code that emulates the XSLT transformation.

public class Dom11{ 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 Dom11 " + "xmlFileIn " + "xformFileOut " + "codeFileOut"); System.exit(0); }//end if Listing 4

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])); Listing 5

1. Create a DocumentBuilderFactory object
2. Use the DocumentBuilderFactory object to create a DocumentBuilder object
3. Use the DocumentBuilder object to create a Document object

Dom11 thisObj = new Dom11(); thisObj.out = new PrintWriter( new FileOutputStream(argv[2])); Listing 6

thisObj.processDocumentNode(document); Listing 7

void processDocumentNode(Node node){ //Write one line of text into the output. out.println("<?xml version=\"1.0\" " + "encoding=\"UTF-8\"?>"); processNode(node); out.flush(); }//end processDocumentNode Listing 8

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 //Process the incoming node based on its // type. int type = node.getNodeType(); Listing 9

switch (type){ case Node.DOCUMENT_NODE:{ if(false){ //cannot be reached in this example }else{//invoke default behavior defElOrRtNodeTemp(node); }//end else break; }//end case DOCUMENT_NODE Listing 10

• Go to the method named processNode, which I am discussing right now.
• 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(false){ //unreachable in this example }else{//invoke default behavior defElOrRtNodeTemp(node); }//end else break; }//end case ELEMENT_NODE Listing 11

void defElOrRtNodeTemp(Node node) throws Exception{ int nodeType = node.getNodeType(); if((nodeType == Node.ELEMENT_NODE) || (nodeType == Node.DOCUMENT_NODE)){ applyTemplates(node,null); }else{ throw new Exception( "Bad call to defElOrRtNodeTemp"); }//end else }//end defElOrRtNodeTemp Listing 12

  <xsl:template match="*|/">
    <xsl:apply-templates/>
  </xsl:template>

Figure 5

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()))){ //Recursive method call processNode(children.item(i)); }//end if }//end for loop }//end if children != null }//end applyTemplates Listing 13

<xsl:apply-templates
  optional attribute select="..."
  optional attribute mode="..."
/>

Figure 6

• The context node.
• The select parameter.

case Node.TEXT_NODE:{ if(false){ //unreachable in this program }else{//invoke default behavior out.print(defTextOrAttrTemp(node)); }//end else break; }//end case Node.TEXT_NODE case Node.ATTRIBUTE_NODE:{ if(false){ //unreachable in this program }else{//invoke default behavior out.print(defTextOrAttrTemp(node)); }//end else break; }//end case Node.ATTRIBUTE_NODE Listing 14

• The processNode method is called with a reference to either a text node or an attribute node, and.
• The default behavior for the node type is executed.

String defTextOrAttrTemp(Node node) throws Exception{ int nodeType = node.getNodeType(); if((nodeType == Node.ATTRIBUTE_NODE) || (nodeType == Node.TEXT_NODE)){ //Get and return value of context node. return valueOf(node,"."); }else{ throw new Exception( "Bad call to defaultTextOrAttr method"); }//end else }//end defaultTextOrAttr Listing 15

  <xsl:template match="text()|@*">
    <xsl:value-of select="."/>
  </xsl:template>

Figure 7

1. valueOf(Node theNode,String "@attrName")
2. valueOf(Node theNode,String ".")
3. valueOf(Node theNode,String "nodeName")

• disable-output-escaping
• processing instruction nodes
• comment nodes
• namespace nodes

1. Element node - return the concatenated text values of all descendant nodes of the context node.
2. Text node - return the text value of the text node.

public String valueOf(Node node,String select){ //code deleted for brevity else if(select != null && select.equals(".")){ int nodeType = node.getNodeType(); if(nodeType == Node.ELEMENT_NODE){ //Process the context node as an element // node. Listing 16

NodeList childNodes = node.getChildNodes(); int listLen = childNodes.getLength(); String nodeTextValue = "";//result Listing 17

for(int j = 0; j < listLen; j++){ nodeTextValue += valueOf(childNodes.item(j),"."); }//end for loop return nodeTextValue; Listing 18

}else if(nodeType == Node.TEXT_NODE){ return node.getNodeValue(); Listing 19

}else{ //ignore all other context node types }//end else }//end if for context node //code deleted for brevity return "";//empty string }//end method valueOf Listing 20

• COMMENT_NODE
• PROCESSING_INSTRUCTION_NODE

case Node.COMMENT_NODE:{ if(false){ //unreachable in this program }else{//invoke default behavior defComOrProcInstrTemp(node); }//end else break; }//end case COMMENT_NODE case Node.PROCESSING_INSTRUCTION_NODE:{ if(false){ //unreachable in this program }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 Listing 21

<?dummy-target dummy-data="def"?> <?xml-stylesheet type="text/xsl" href="Dom11.xsl"?> <?false-target false-data="ghi"?> Listing 22

String defComOrProcInstrTemp(Node node) throws Exception{ int nodeType = node.getNodeType(); if((nodeType == Node.COMMENT_NODE) || (nodeType == Node.PROCESSING_INSTRUCTION_NODE)){ return "";//empty string }else{ throw new Exception("Bad call to " + "defalutCommentOrProcInstrTemplate"); }//end else }//end defComOrProcInstrTemp Listing 23

<xsl:template
  match="processing-instruction()|comment()"

Figure 8

default:{ //Ignore all other node types. }//end default }//end switch Listing 24

thisObj.doXslTransform( document,argv[1],procInstr); Listing 25

• Identifying the processing instruction containing the stylesheet information.
• Extracting the stylesheet information from the 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 Listing 26

<?xml-stylesheet 
  type="text/xsl" href="Dom11.xsl"?>

Figure 9

String xslFile = pi.getData(). substring(pi.getData().indexOf( "href=")+6); //Eliminate the quotation mark at the end xslFile = xslFile.substring( 0,xslFile.length()-1); Listing 27

//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 Listing 28

1. Create a TransformerFactory object by invoking the static newInstance method of the TransformerFactory class.
2. Invoke the newTransformer method on the TransformerFactory object.

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

Summary

What's Next?

In the next lesson, I will show you  how to write a Java program that mimics an XSLT transformation for converting an XML file into a text file.  I will also show 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.

<?xml version="1.0"?> <!DOCTYPE top [ <!ELEMENT top (theData)*> <!ELEMENT theData (title,author,price)*> <!ELEMENT title (#PCDATA | subtitle)*> <!ELEMENT author (#PCDATA)> <!ELEMENT price (#PCDATA)> <!ELEMENT subtitle (#PCDATA)> <!ATTLIST theData attr CDATA #IMPLIED> <!ATTLIST subtitle position CDATA #IMPLIED> ]> <!-- File Dom11.xml Copyright 2003 R. G. Baldwin Illustrates built-in template rules. --> <!--Two of the following proc instr were included to test the ability of the program to find the actual stylesheet proc instr.--> <?dummy-target dummy-data="def"?> <?xml-stylesheet type="text/xsl" href="Dom11.xsl"?> <?false-target false-data="ghi"?> <top> <theData attr="Dummy Attr Value"> <title>Java <subtitle position="Low">really</subtitle>rules </title> <author>R.Baldwin</author> <price>$9.95</price> </theData> <theData> <title>Python</title> <author>R.Baldwin</author> <price>$15.42</price> </theData> <theData> <title>XML</title> <author>R.Baldwin</author> <price>$19.60</price> </theData> </top> Listing 29

<?xml version='1.0'?> <!-- File Dom11.xsl Copyright 2003 R. G. Baldwin Illustrates extraction of text from an XML file. This version specifies a template rule that guarantees that the root and all child nodes are processed. It also specifies a template rule that copies the value of text and attribute nodes into the output. However, attribute nodes are not copied. See Nutshell page 147 for the reason. --> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> <!--According to Nutshell, this matches a default template.--> <xsl:template match="*|/"> <xsl:apply-templates/> </xsl:template> <!--According to Nutshell, this matches a default template.--> <xsl:template match="text()|@*"> <xsl:value-of select="."/> </xsl:template> </xsl:stylesheet> Listing 30

/*File Dom11.java Copyright 2003 R.G.Baldwin This program implements all six built-in default template rules for an XML processor. In addition, it implements a couple of other template rules that are required to support the built-in rules, such as xsl:value-of. As such, the program serves as the skeleton for the definition of 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. As written, this program extracts and concatenates all text values from a specified XML file, and writes that text into a result file, using two different approaches: 1. An XSLT style sheet and transformation. 2. Program code that emulates the behavior of the XSL transformation. In particular, this program illustrates Java code that emulates the XSLT templates in the files named Dom11.xsl and Dom11.xsl. These two XSL files differ in terms of their dependence on the built-in templates. Dom11.xsl explicitly includes template rules that replicate the built-in rules for text, nodes, and documents. Dom11.xsl doesn't explicitly include any template rules, but depends entirely on built-in rules for proper operation. Both XSL files produce the same result when processed against the XML files named Doc11.xml and Dom11.xml, demonstrating the behavior of the built-in template rules. The execution of these template rules causes the explicit template rules, or the built-in template rules to be executed on every node, thereby causing the contents of every text node to be concatenated and written into the result file. The program requires three command line parameters in the following order: 1, The name of the input XML file - must be Dom11.xml or Dom11.xml. 2. The name of the output file to be produced by the XSL transformation. 3. The name of the output file to be produced by the program code that emulates the XSL transformation. 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. 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 Dom11{ 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 Dom11 " + "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 /// Dom11 thisObj = new Dom11(); //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){ //Write one line of text into the output. /// out.println("<?xml version=\"1.0\" " + "encoding=\"UTF-8\"?>"); //Go process the root (document) node. This // method call triggers a recursive process // that processes the entire DOM tree. /// processNode(node); 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(false){ //Change conditional and write // overriding handler here /// }else{//invoke 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(false){ //Change conditional and write // overriding handler here /// }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 /// //Save proc instr for later use procInstr.add(node); }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 // attribute 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 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 Dom11 Listing 31

<?xml version="1.0"?> <!DOCTYPE top [ <!ELEMENT top (theData)*> <!ELEMENT theData (title,author,price)*> <!ELEMENT title (#PCDATA | subtitle)*> <!ELEMENT author (#PCDATA)> <!ELEMENT price (#PCDATA)> <!ELEMENT subtitle (#PCDATA)> <!ATTLIST theData attr CDATA #IMPLIED> <!ATTLIST subtitle position CDATA #IMPLIED> ]> <!-- File Dom11a.xml Copyright 2003 R. G. Baldwin Illustrates built-in template rules. Same as Dom11.xml except for stylesheet specification. --> <!--Two of the following proc instr were included to test the ability of the program to find the actual stylesheet proc instr.--> <?dummy-target dummy-data="def"?> <?xml-stylesheet type="text/xsl" href="Dom11a.xsl"?> <?false-target false-data="ghi"?> <top> <theData attr="Dummy Attr Value"> <title>Java <subtitle position="Low">really</subtitle>rules </title> <author>R.Baldwin</author> <price>$9.95</price> </theData> <theData> <title>Python</title> <author>R.Baldwin</author> <price>$15.42</price> </theData> <theData> <title>XML</title> <author>R.Baldwin</author> <price>$19.60</price> </theData> </top> Listing 32

<?xml version='1.0'?> <!-- File Dom11a.xsl Copyright 2003 R. G. Baldwin Illustrates extraction of text from an XML file. This version accepts a built-in template rule that guarantees that the root and all child nodes are processed. It also accepts the built-in template rule that copies the value of text and attribute nodes into the output. However, attribute nodes are not copied. See Nutshell page 147 for the reason. As a result, the stylesheet is completely empty. --> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> </xsl:stylesheet> Listing 33

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-