Java JAXP, Writing Java Code to Emulate an XSLT Transformation

<?xml version="1.0" encoding="UTF-8"?>

A Match Root

B Match top

C Match theData and show attribute
Dummy Attr Value
D Match title and show value of title as context
Java
really
This is part 1
This is part 2
rules
 ...

Figure 11

        subtitle ELEMENT_NODE
             Attribute: position=Low
           #text really
          part1 ELEMENT_NODE
             #text This is part 1
           part2 ELEMENT_NODE
             #text This is part 2

Figure 12

<?xml version="1.0" encoding="UTF-8"?>

A Match Root

B Match top

C Match theData and show attribute
Dummy Attr Value
D Match title and show value of title as context
Java
really
This is part 1
This is part 2
rules
E Show value of subtitle
really
This is part 1
This is part 2
...

Figure 13

    xsl:template ELEMENT_NODE
        Attribute: match=subtitle
      #text
F match subtitle and show value of attribute
      xsl:value-of ELEMENT_NODE
          Attribute: select=@position
      #text
G Show value of subtitle as context node
      xsl:value-of ELEMENT_NODE
          Attribute: select=.

Figure 14

<xsl:template match="subtitle">
F match subtitle and show value of attribute
<xsl:value-of select="@position" />
G Show value of subtitle as context node
<xsl:value-of select="." />
</xsl:template>

Listing 5

        subtitle ELEMENT_NODE
             Attribute: position=Low
           #text really
          part1 ELEMENT_NODE
             #text This is part 1
           part2 ELEMENT_NODE
             #text This is part 2

Figure 15

<?xml version="1.0" encoding="UTF-8"?>

A Match Root

B Match top

C Match theData and show attribute
Dummy Attr Value
D Match title and show value of title as context
Java
really
This is part 1
This is part 2
rules
E Show value of subtitle
really
This is part 1
This is part 2

F match subtitle and show value of attribute
Low
G Show value of subtitle as context node
really
This is part 1
This is part 2
...

Figure 16

      author ELEMENT_NODE
         #text R.Baldwin
       price ELEMENT_NODE
         #text $9.95

Figure 17

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

Figure 18

C Match theData and show attribute

D Match title and show value of title as context
Python
E Show value of subtitle

...

Figure 19

public class Dom12{
    //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 6

  void processDocumentNode(Node node){
    out.println("<?xml version=\"1.0\" "
                       + "encoding=\"UTF-8\"?>");
    out.println("A Match Root");

    //Go process the root (document) node.
    processNode(node);

    out.flush();
  }//end processDocumentNode

Listing 7

  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 8

      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 9

        case Node.ELEMENT_NODE:{
          if(node.getNodeName().equals("top")){
            out.println("B Match top");
            applyTemplates(node,"theData");

Listing 10

          }else if(node.getNodeName().equals(
                                     "theData")){
            out.println("C Match theData and "
                             + "show attribute");
            out.println(valueOf(node,"@attr"));
            applyTemplates(node,"title");

Listing 11

  public String valueOf(Node node,String select){

    if(select != null
                     && select.charAt(0) == '@'){

      String attrName = select.substring(1);

Listing 12

      NamedNodeMap attrList =
                            node.getAttributes();
      Node attrNode = attrList.getNamedItem(
                                       attrName);

Listing 13

      if(attrNode != null){
        return attrNode.getNodeValue();
      }else{
        return "";//empty string
      }//end else
    }//end if on @

Listing 14

    else if(select != null
                          && select.equals(".")){
      //Process the context node
      //Code deleted for brevity
    }//end if for context node

    else if(select != null){
      //Process a selected child node
      //Code deleted for brevity
    }//end else if(select != null)

    return "";//empty string
  }//end method valueOf

Listing 15

          }else if(node.getNodeName().equals(
                                       "title")){
            out.println("D Match title and show "
                  + "value of title as context");
            out.println(valueOf(node,"."));

Listing 16

            out.println(
                     "E Show value of subtitle");
            out.println(valueOf(
                               node,"subtitle"));
            applyTemplates(node,"subtitle");

Listing 17

  public String valueOf(Node node,String select){

    if(select != null
                     && select.charAt(0) == '@'){
      //Request for the value of an attribute.
      //Code deleted for brevity
    }//end if on @

    else if(select != null
                          && select.equals(".")){
      //Process the context node
      //Code deleted for brevity
    }//end if for context node

Listing 18

    else if(select != null){
      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
          return valueOf(children.item(i),".");
        }//end if getNodeName == select
      }//end for loop on all child nodes
    }//end else if(select != null)
    return "";//empty string
  }//end method valueOf

Listing 19

          }else if(node.getNodeName().equals(
                                    "subtitle")){
            out.println("F match subtitle and "
                    + "show value of attribute");
            out.println(valueOf(
                              node,"@position"));
            out.println("G Show value of "
                   + "subtitle as context node");
            out.println(valueOf(node,"."));

Listing 20

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

Listing 21

      switch (type){

        //Code extracted for detailed discussion

        case Node.TEXT_NODE:{
          if(false){
          }else{//invoke default behavior
            out.print(defTextOrAttrTemp(node));
          }//end else
          break;
        }//end case Node.TEXT_NODE

        case Node.ATTRIBUTE_NODE:{
          if(false){
          }else{//invoke default behavior
            out.print(defTextOrAttrTemp(node));
          }//end else
          break;
        }//end case Node.ATTRIBUTE_NODE

        case Node.COMMENT_NODE:{
          if(false){
          }else{//invoke default behavior
            defComOrProcInstrTemp(node);
          }//end else
          break;
        }//end case COMMENT_NODE

        case Node.PROCESSING_INSTRUCTION_NODE:{
          if(false){
          }else{//invoke default behavior
            //Save proc instr for later use.
            procInstr.add(node);
            //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)

Listing 22

case Node.ELEMENT_NODE:{
if(node.getNodeName().equals("top")){
out.println("B Match top");
applyTemplates(node,"theData");

}else if(node.getNodeName().equals("theData")){
out.println(
           "C Match theData and show attribute");
out.println(valueOf(node,"@attr"));
applyTemplates(node,"title");

}else if(node.getNodeName().equals("title")){
out.println(
      "D Match title and show value of title as "
                                    + "context");
out.println(valueOf(node,"."));
out.println("E Show value of subtitle");
out.println(valueOf(node,"subtitle"));
applyTemplates(node,"subtitle");

}else if(node.getNodeName().equals("subtitle")){
out.println(
 "F match subtitle and show value of attribute");
out.println(valueOf(node,"@position"));
out.println(
     "G Show value of subtitle as context node");
out.println(valueOf(node,"."));

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

Listing 23

/*File Dom12.java
Copyright 2003 R.G.Baldwin

This is an update of Dom11 designed to test
features of various methods that were not 
tested by the sample used with Dom11.

Mainly, this version adds code to the processNode
method to simulate the template rules in the
XSL file named Dom12.xsl.

Also, as before, this program implements all six
built-in template rules for an XML processor.

To create a custom template 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.

This program compares the transformation of a
specified XML file 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 file
named Dom12.xsl.

The program requires three command line
parameters in the following order:
1, The name of the input XML file - must be
   Dom12.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 Dom12{

  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 Dom12 "
        + "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
      ///
      Dom12 thisObj = new Dom12();

      //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\"?>");
    out.println("A Match Root");

    //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(node.getNodeName().equals("top")){
            out.println("B Match top");
            applyTemplates(node,"theData");
          }else if(node.getNodeName().equals(
                                     "theData")){
            out.println("C Match theData and "
                             + "show attribute");
            out.println(valueOf(node,"@attr"));
            applyTemplates(node,"title");
          }else if(node.getNodeName().equals(
                                       "title")){
            out.println("D Match title and show "
                  + "value of title as context");
            out.println(valueOf(node,"."));
            out.println(
                     "E Show value of subtitle");
            out.println(valueOf(
                               node,"subtitle"));
            applyTemplates(node,"subtitle");
          }else if(node.getNodeName().equals(
                                    "subtitle")){
            out.println("F match subtitle and "
                    + "show value of attribute");
            out.println(valueOf(
                              node,"@position"));
            out.println("G Show value of "
                   + "subtitle as context node");
            out.println(valueOf(node,"."));
          }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
  // 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 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 Dom12

Listing 24

<?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 | part1 | part2)*>
<!ELEMENT part1 (#PCDATA)>
<!ELEMENT part2 (#PCDATA)>
<!ATTLIST theData attr CDATA #IMPLIED>
<!ATTLIST subtitle position CDATA #IMPLIED>
]>

<!-- File Dom12.xml
Copyright 2003 R. G. Baldwin
-->

<!--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="Dom12.xsl"?>
<?false-target false-data="ghi"?>

<top>

<theData attr="Dummy Attr Value">
<title>Java
<subtitle position="Low">really
<part1>This is part 1</part1>
<part2>This is part 2</part2>
</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 25

<?xml version='1.0'?>
<!-- File Dom12.xsl
Copyright 2003 R. G. Baldwin
-->
<xsl:stylesheet 
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">

<xsl:template match="/">
A Match Root
<xsl:apply-templates select="top" />
</xsl:template>

<xsl:template match="top">
B Match top
<xsl:apply-templates select="theData" />
</xsl:template>

<xsl:template match="theData">
C Match theData and show attribute
<xsl:value-of select="@attr" />
<xsl:apply-templates select="title" />
</xsl:template>

<xsl:template match="title">
D Match title and show value of title as context
<xsl:value-of select="." />
E Show value of subtitle
<xsl:value-of select="subtitle" />
<xsl:apply-templates select="subtitle" />
</xsl:template>

<xsl:template match="subtitle">
F match subtitle and show value of attribute
<xsl:value-of select="@position" />
G Show value of subtitle as context node
<xsl:value-of select="." />
</xsl:template>

</xsl:stylesheet>

Listing 26