Caucho maker of Resin Server | Application Server (Java EE Certified) and Web Server


 

Resin Documentation

home company blog wiki docs 
app server web server 
health cloud java ee pro 
 Resin Server | Application Server (Java EE Certified) and Web Server
 

xslt extensible stylesheet language


The extensible stylesheet language is a language for transforming XML documents to new XML documents. It's based on matching elements in the XML tree and replacing the element with new XML. For example, replacing a 'definition' tag with an HTML table with a silver background.

Introduction

XSLT processes the input document recursively from the top down, essentially a depth first traversal of the tree. When it examines each node, it finds the best match from all the templates. XSLT then follows the processing instructions for the matching template, usually adding text to the output.

If XSLT cannot find a matching template, it applies default rules. Text gets copied to the output. The children of elements are processed, but the elements themselves are not copied. So a completely blank XSLT stylesheet will remove all the tags and just print out the text.

When it's done with the current node, XSLT moves to the next one until the entire input tree is complete.

For example, it might process an HTML file in the following order:

  1. HTML
  2. HEAD
  3. TITLE
  4. META
  5. BODY
  6. P
  7. TEXT
  8. etc

Resin's XSLT follows the 1.0 W3C specification.

XSLT core

<xsl:stylesheet>

The top-level element of an XSL stylesheet.

<xsl:template ... > ...

Establishes a pattern and replacement text.

xsl:template registers its pattern with the XSL processing engine. When a node matches the pattern, XSL will process the contents of the template.

Pure XSL processes the contents slightly differently than XTP. XSL expects all tags to be valid XML. XTP is more forgiving. If the tag is not one of those defined by XSL, it will treat the tag as raw text.

ATTRIBUTEMEANING
matchthe XPath match pattern (required)
modestring grouping templates into a special mode
nameName for later use by xsl:call-template
priorityconflict-resolving priority, an integer

In the following example, the template matches any 'box' tag. The contents of the box are placed in a centered table 80% of the current width.

This example is legal in XTP because the <td> and <tr> are treated as raw text. The example is illegal in XSL because those tags are missing their close tags.

<xsl:template match='box'>
  <center>
  <table width='80%'>
  <tr><td>

    <xsl:apply-templates/>

  </td></tr>
  </table>
  </center>

</xsl:template>
<p>Here's a boxed quote,</p>

<box>
To be or not to be...
</box>
<p>Here's a boxed quote,</p>

<center>
<table width='80%'>
<tr><td>

  To be or not to be...

</table>
</center>

<xsl:apply-templates ... > ...

Evaluates the children of the current node.

xsl:apply-templates recursively processes the children. If a template has no xsl:apply-templates, then the children are ignored.

ATTRIBUTEMEANING
selectAn XPath select pattern selecting the nodes to evaluate next. (optional)
modeonly selects templates with the given mode

The first example doubles the contents by calling xsl:apply-templates twice.

<xsl:template match='double'>
  <xsl:apply-templates/>
  <xsl:apply-templates/>
</xsl:template>
<double>
Some <foo/> text.
</double>
Some <foo/> text.
Some <foo/> text.

The select pattern can restrict the children to evaluate. Stylesheets can use it to select elements and to reorder them.

The following example writes the 'a' nodes followed by the 'b' nodes and ignores everything else.

<xsl:template match='a-b-test'>
  <xsl:apply-templates select='a'/>
  <xsl:apply-templates select='b'/>
</xsl:template>
<a-b-test>
  Junk Text.
  <b/>
  <a>
    Good text.
  </a>
  More Junk.
  <b>
    Some B text.
  </b>
  <a>
    More Good text.
  </a>
</a-b-test>
<a>
  Good text.
</a>
<a>
  More Good text.
</a>
<b/>
<b>
  Some B text.
<b>

<xsl:text> ...

Writes the contents to the output.

xsl:text is useful when you need to force spacing or special text. Usually, Resin will produce the text you expect. xsl:text is there for the strange cases when you need full control.

<xsl:value-of .../>

Writes a calculated value output.

ATTRIBUTEMEANING
selectAn XPath expression to be printed.

value-of is particularly useful for extracting attribute values. The following example creates a JSP tag which adds two numbers.

<xsl:template match='ct:sum'>
<jsp:expression>
<xsl:value-of select='@a'> + <xsl:value-of select='@b'>
</jsp:expression>
</xsl:template>

<xsl:for-each ...> ...

Loops over child select patterns.

xsl:foreach gives stylesheets complete control over the actions for child nodes.

Usually, stylesheets will want to use the full pattern matching capability given by XSL. Sometimes the specific structure is known, like sections in a chapter. When generating a table of contents, it may be easier to scan over the sections.

ATTRIBUTEMEANING
selectXPath select pattern
<xsl:template match='contents'>
  <ol>
  <xsl:for-each select='section'>
    <li><xsl:value-of select='@title'/></li>
  </xsl:for-each>
  </ol>
</xsl:template>

<xsl:if ...> ...

Evaluates the containing content if an expression evaluates to true.

ATTRIBUTEMEANING
testXPath expression evaluating to a boolean.

<xsl:import .../>

Imports a stylesheet.

xsl:import lets stylesheets borrow from each other.

ATTRIBUTEMEANING
hrefPath to the imported stylesheet

<xsl:output .../>

Control the output printing.

ATTRIBUTEMEANING
methodxml or html or text. Select printing method
versionXML version
encodingcharacter set to print the results
omit-xml-declarationskip the XML or HTML declaration
indentpretty-print or not
media-typemime-type
disable-output-escaping'<' gets printed as '<', not '&lt;'

XSLT

<xsl:element>

Creates a new element.

The name can be computed using an attribute value template.

ATTRIBUTEMEANING
nameName of the new element.
<xsl:template match='a'>
  <xsl:element name='b{@id}'>
    <c/>
  </xsl:element>
</xsl:template>
<b3><c/></b3>

<xsl:attribute>

Adds an attribute to the element.

The name can be computed using an attribute value template.

ATTRIBUTEMEANING
nameName of the new attribute.
<xsl:template match='a'>
  <c>
    <xsl:attribute name='b{@id}'>
    <xsl:value-of select='c{@id}'/>
    </xsl:attribute>
  </c>
</xsl:template>
<c b3='c3'/>

<xsl:attribute-set>

Defines a named attribute set.

The attributes in the set are defined by xsl:attribute elements.

ATTRIBUTEMEANING
nameName of the attribute set.
<xsl:attribute-set name='font'>
  <xsl:attribute name='font-size'>12pt</xsl:attribute>
  <xsl:attribute name='font-weight'>bold</xsl:attribute>
</xsl:attribute-set>

<xsl:template match='a'>
  <c xsl:use-attribute-sets='font'/>
</xsl:template>
<c font-size='12pt' font-weight='bold'/>

<xsl:processing-instruction>

Creates a new processing instruction.

ATTRIBUTEMEANING
nameProcessing instruction name.
<xsl:template match='a'>
  <xsl:processing-instruction name='foo'>
  <xsl:text>Text for the PI</xsl:text>
  </xsl:processing-instruction/>
</xsl:template>
<?foo Text for the PI?>

<xsl:comment>

Creates a new comment.

The contents of the xsl:comment element become the contents of the comment.

<xsl:template match='a'>
  <xsl:comment>
  <xsl:text>Text for the comment</xsl:text>
  </xsl:processing-instruction/>
</xsl:template>
<!--Text for the comment-->

<xsl:copy>

Copies the current node, but not children or attributes, to the output.

To copy an element, a stylesheet must copy the attributes as well.

The following example is the identity stylesheet. It copies input to the output including the attributes.

<xsl:template match='@*|node()'>
  <xsl:copy>
    <xsl:apply-templates select='@*|node()'/>
  </xsl:copy>
</xsl:template>

<xsl:copy-of .../>

Copies a sub-tree into the output.

copy-of resembles value-of. value-of always converts the value to a string. copy-of will copy subtrees.

ATTRIBUTEMEANING
selectAn XPath expression to be copied.

<xsl:variable>

Assignes an XSL variable.

Variables can be retrieved using the XPath variable syntax.

ATTRIBUTEMEANING
namevariable name
selectvariable value
<xsl:variable name='foo' select='1+1'/>

<xsl:template match='a'>
  <xsl:value-of select='$foo'/>
</xsl:template>
2

<xsl:call-template>

Calls a named template with the current node.

xsl:call-template lets stylesheets reuse common code, like functions. It works like xsl:apply-templates select='.' except that it calls based on a template name.

ATTRIBUTEMEANING
nametemplate name to call
modetemplate mode

<xsl:param>

Declares an XSL parameter.

xsl:param's select parameter as a default. If the variable has been assigned, it uses the old value.

ATTRIBUTEMEANING
namevariable name
selectvariable value
<xsl:template name='fun'>
  <xsl:param name='foo' select='15'/>
  <xsl:value-of select='$foo'/>
</xsl:template>

<xsl:template match='a'>
  <xsl:call-template name='foo'>
    <xsl:with-param name='foo' select='1+2'/>
  </xsl:call-template>
</xsl:template>
3

<xsl:apply-imports>

Like Java's super, calls the overridden template.

<xsl:sort>

Sorts nodes in xsl:apply-templates or xsl:for-each.

ATTRIBUTEMEANING
selectvalue to sort on (default = '.')
orderascending or descending (default = ascending)
data-typetext or number (default = text)
note
Note
case-order and lang attributes are not implemented

<xsl:choose ...> ...

Implements an if-elsif-else block.

The xsl:when statements are tested in order. The first matching one is executed. If none match, the xsl:otherwise block is executed.

ATTRIBUTEMEANING
testXPath expression evaluating to a boolean.
<xsl:template match='a'>
  <xsl:choose>
  <xsl:when test='@color="red"'>
    <xsl:text>stop</xsl:text>
  </xsl:when>
  <xsl:when test='@color="green"'>
    <xsl:text>go</xsl:text>
  </xsl:when>
  <xsl:otherwise>
    <xsl:text>yield</xsl:text>
  </xsl:otherwise>
  </xsl:choose>
</xsl:template>

Resin extensions

<xtp:expression>expression ...

Executes expression and prints it to the output.

Stylesheets can use any JavaScript expression. The following variables are pre-defined in stylesheets.

VARIABLEMEANING
nodeThe current org.w3c.dom.Node.
outThe com.caucho.xsl.XslWriter.

In addition, the out variable gives access to the servlet PageContext with the page property.

<xsl:template match='welcome-user'>
  <xsl:text>Welcome back, </xsl:text>
  <xtp:expression>
    out.page.session.value.user
  <xtp:expression>
</xsl:template>

<xtp:scriptlet> statement_list

Executes the statement_list scriptlet.

The JavaScript code can be any statement list. The same implicit variables are allowed in scriptlets as in expressions.

The following example creates a number of stars:

<@# page language='javascript' #>
<xsl:template match='ct:stars'>
  <xtp:scriptlet>
    for (var i = 0; i < node.attribute.count; i++)
      out.write('*');
  </xtp:scriptlet>
</xsl:template>
1 = <ct:stars count='1'/>
9 = <ct:stars count='9'/>
1 = *
9 = *********

<xtp:declaration>

Adds declaration code, i.e. code outside of any function.

<xtp:declaration>
function dist(x1, y1, x2, y2)
{
  return Math.sqrt((x1 - x2) * (x1 - x2) +
                   (y1 - y2) * (y1 - y2));
}
</xtp:declaration>

<xtp:directive.page attributes />

Sets page directives

NAMEMEANING
languagescript language, default Java
sessionuse sessions, default false
errorPagepage to display for errors
errorPagepage to display for errors
importimports Java packages
contentTypecontent-type of the generated page

Copyright © 1998-2012 Caucho Technology, Inc. All rights reserved. Resin ® is a registered trademark. Quercustm, and Hessiantm are trademarks of Caucho Technology.

Cloud-optimized Resin Server is a Java EE certified Java Application Server, and Web Server, and Distributed Cache Server (Memcached).
Leading companies worldwide with demand for reliability and high performance web applications including SalesForce.com, CNET, DZone and many more are powered by Resin.

home company blog wiki docs 
app server web server 
health cloud java ee pro