Xalan-Java Interpretive samples:
Xalan-Java Interpretive servlet samples:
Xalan-Java Compiled samples:
|
|
What it
does: The SimpleTransform class uses the birds.xsl stylesheet to
transform birds.xml, and prints the output to birds.out.
You can
run it from the SimpleTransform subdirectory with
java
SimpleTransform
|
|
|
What it
does: The UseStylesheetPI class uses the stylesheet processing
instruction in the XML source document to determine which
stylesheet to use to perform the transformation.
You can
run it from the UseStylesheetPI subdirectory with
java
UseStylesheetPI
For more
information, see Working with
embedded stylesheets.
|
|
|
What it
does: The UseStyleSheetParam class uses foo.xsl and a stylesheet
parameter to transform foo.xml, and prints the output to
System.out. The stylesheet parameter appears as a text node in the
output.
Run this
sample from the UseStylesheetParam subdirectory with
java UseStylesheetParam
param
where
param is the stylesheet parameter value (a string of your
choice).
|
|
|
What it
does: Explicitly set the SAX XMLReader and SAX ContentHandler for
processing the stylesheet (birds.xsl), processing the XML input
(birds.xml), and producing the output (birds.out).
Run this
sample from the SAX2SAX subdirectory with
java SAX2SAX
|
|
|
What it
does: the DOM2DOM class uses the birds.xsl stylesheet to transform
a DOM Document generated from birds.xml, produces an output DOM,
and traverses the DOM, printing the traversal to System.out. In
contrast to SimpleTransform, DOM2DOM illustrates the procedure for
processing an input DOM and creating an output DOM that is
available for further processing.
You can
run it from the DOM2DOM subdirectory with
java DOM2DOM
|
|
|
What it
does: Pipes the output from one transformation to a second
transformation, then from the second transformation to the third
transformation. Transformer1 is the ContentHandler for the
XMLReader (which parses the input document). Transformer2 provides
the ContentHandler for Transformer1, and Transformer3 for
Transformer2.
 |
Pipe and UseXMLFilters
illustrate two strategies for using the output of one
transformation as the input for another transformation. The Pipe
sample incorporates a "push" model -- Transformer1 "pushes" its
output to Transformer2, and so on -- whereas in the UseXMLFilters
sample, Transformer3 "pulls" its input from Transformer2, and so
on. |
Run this
sample from the Pipe subdirectory with
java Pipe
|
|
|
What it
does: Chains together the same transformations as the preceding
Pipe sample. Using each Transformer object as an extension of the
SAX XMLFilter interface, sets the XMLReader as the parent of
filter1, filter1 as the parent of filter2, and filter2 as the
parent of of filter3.

Run this
sample from the UseXMLFilters subdirectory with
java
UseXMLFilters
|
|
|
What it
does: ApplyXPath uses the
XPathAPI convenience methods to execute an XPath expression
against an XML document and return the nodes (if any) it
finds.
 |
You can use this
sample as an aid when you want to find out what a given XPath
expression returns from a given XML file. Keep in mind that the
context node (base point of evaluation) for the XPath expression is
the document root. |
Run this
sample from the ApplyXPath subdirectory with
java ApplyXPath XMLFile
XPathExpression
where
XMLFile is an XML source file and XPathExpression is
an XPath expression to apply to that file. The ApplyXPath
subdirectory contains an XML file named foo.xml --
<doc><name first="David"
last="Marston"/>...</doc>
-- so you can try command lines like
java ApplyXPath foo.xml
/
and
java ApplyXPath foo.xml
/doc/name/@first
For more
information, see Working with
XPath expressions.
|
|
|
What it
does: ApplyXPathDOM is very similar to the ApplyXPath sample, but it uses
the API in the DOM
Level 3 XPath Specification to execute an XPath expression
against an XML document and return the nodes (if any) it finds. At
the time of writing the DOM Level 3 XPath Specification is in
Last Call.
 |
You can use this
sample as an aid when you want to find out what a given XPath
expression returns from a given XML file. Keep in mind that the
context node (base point of evaluation) for the XPath expression is
the document root. |
Run this
sample from the ApplyXPathDOM subdirectory with
java ApplyXPathDOM XMLFile
XPathExpression
where
XMLFile is an XML source file and XPathExpression is
an XPath expression to apply to that file. The ApplyXPathDOM
subdirectory contains an XML file named foo.xml --
<doc><name first="David"
last="Marston"/>...</doc>
-- so you can try command lines like
java ApplyXPathDOM foo.xml
/
and
java ApplyXPathDOM foo.xml
/doc/name/@first
For more
information, see Working with
XPath expressions.
|
|
|
The applet
uses a stylesheet to transform an XML document into HTML. It
displays the XML document, the stylesheet, and the HTML
output.
How to run
it: Open appletXMLtoHTML.hmtl in the Internet Explorer 5
browser.
 |
For information about
running Xalan-Java applets in Netscape Communicator, see Problems with
Netscape.
This applet looks for xalan.jar, xml-apis.jar, and xercesImpl.jar
(Xerces-J2) or xerces.jar (Xerces-J 1) in the bin subdirectory. If
you have placed these JAR files elsewhere, adjust the applet
archive setting in client.html accordingly. |
|
|
|
For a
general introduction, see Using Xalan-Java in a
servlet.
The
servlet subdirectory contains four sample servlets and one JSP that
use Xalan-Java to perform transformations. The sample code is
compiled and packed in xalanservlet.war. To run these samples, you
must place xalanservlet.war on a web server with a servlet engine.
For example, using jakarta-tomcat
4.1.18. Copy the xalanservlet.war to %Tomcat_Home%/webapps. For
more detail about deploying servlet on Tomcat, please refer to
Deployment Organization.
 |
Dependency on Tomcat
version. If encountering "java.lang.VerifyError: Cannot inherit
from final class" error, replace xercesImpl.jar under
%Tomcat_Home%/common/endorsed with the one included with Xalan-Java
. |
servlet.SimpleXSLTServlet
applies a particular stylesheet to a particular XML
document.
servlet.UseStylesheetParamServlet
sets a stylesheet parameter (the parameter name is hardwired into
the servlet), and requires the user to supply parameters for the
XML document and XSL stylesheet.
jspSample.jsp is a Java
ServerPage that sets a stylesheet parameter and applies the
stylesheet to the XML document.
servlet.XSLTServletWithParams
accepts parameters for the XML document, the XSL stylesheet, and
any number of stylesheet parameters.
servlet.ApplyXSLT (and associated
classes) is closer to a production level servlet. It accepts
parameters, provides a listener for capturing and reporting
debugger messages, and supports use of a property file to determine
which stylesheet to apply based on the identity of the client
browser/device.
|
|
 |
Paul Campbell
<seapwc@halcyon.com> wrote this Java Server
Page. |
This Java Server Page performs essentially the same
operation as servlet.UseStylesheetParamServlet.
It applies a stylesheet parameter to a stylesheet (fooparam.xsl),
applies the stylesheet to an XML source document (fooparam.xml),
and returns the result.
Call JSP as follows:
- http://localhost:port/xalanservlet/jspSample.jsp?
XML=fooparam.xml&XSL=fooparam.xsl&PMA=GoodBye
The JSP obtains the PMA value "GoodBye" from the http
request and passes it to the stylesheet as the paramValue argument
in a Transformer setParameter() call.
|
|
|
What it does: The client (which you must set up)
specifies an XML document and a stylesheet. The servlet performs
the transformation and returns the output to the client. You can
use media.properties to specify which stylesheet is to be used
depending on the client browser/device.
 |
The source files for
this servlet, including ApplyXSLT.java, ApplyXSLTProperties.java,
DefaultApplyXSLTProperties.java, ApplyXSLTListener.java,
ApplyXSLTException.java. booklist1.xsl, booklist2.xsl and
catalog.xml, are provided for testing. |
To run the servlet: set system property
server.root=server root. Set up an HTML page to call
servlet.ApplyXSLT with arguments as illustrated below.
The files catalog.xml, booklist1.xsl and booklist2.xsl
are used in the following example. In the deploy descriptor,
booklist1.xsl is set as the default xsl file. If you create these
files yourself, be careful that the output method should be set to
"xml" in the stylesheet.
Examples:
- http://localhost:port/xalanservlet/ApplyXSLT?URL=/xalanservlet/catalog.xml&xslURL=
/xalanservlet/booklist2.xsl
- ...applies the booklist2.xsl stylesheet to the
catalog.xml data. Both files are
served from the Web server's HTTP document root.
- http://localhost:port/xalanservlet/ApplyXSLT?URL=/xalanservlet/catalog.xml&xslURL=
/xalanservlet/booklist2.xsl&debug=true
- ...ensures that XML and XSL processor messages are
returned in the event of problems applying booklist2.xsl to
catalog.xml
- http://localhost:port/xalanservlet/ApplyXSLT/xalanservlet/catalog.xml?xslURL=/xalanservlet/booklist2.xsl
- ...applies the booklist2.xsl stylesheet to the
catalog.xml data, just like the first example. This is an
alternative way of specifying the XML XSLTInputSource by utilizing
the HTTP request's path information.
- http://localhost:port/xalanservlet/ApplyXSLT/xalanservlet/catalog.xml
- ...examines catalog.xml for an associated XSL stylesheet
booklist1.xsl (a stylesheet Processing Instruction). If multiple
XSLs are associated with the data, the stylesheet whose media
attribute maps to your browser type will be chosen. If no mapping
is successful, the primary associated stylesheet is used.
|
|
|
|
For an
introduction to the creation and use of extension elements and
extension functions, and for information about the extensions
library distributed with the Xalan-Java Interpretive processor, see
Extensions. Extensions are also
supported for the Xalan-Java Compiling processor (XSLTC), however
no samples exist at this time. See Extensions for XSLTC.
The
extensions subdirectory contains six samples with Xalan-Java
Interpretive extensions. Two of the samples use extensions
implemented in JavaScript, and four of the samples use extensions
implemented in Java.
To run
these examples, you must place bsf.jar (distributed with
Xalan-Java), and js.jar (version 1.5, available from http://www.mozilla.org/rhino)
on the classpath. You do not need js.jar on the classpath for the
samples that use Java extensions. Problems
related to JDK 1.4
Use
java.org.apache.xalan.xslt.Process, the Xalan-Java command-line
utility, to run most of these samples from the command line. The command line must
include an -in flag with the XML source and an -xsl flag with the
XSL stylesheet. If you want the output to be written to a file,
rather than to the screen, add an -out flag with the output file
name.
Run these
samples from the extensions directory as follows (each of the
following is a single command line):
|
|
What it does: Uses the Redirect extension elements
shipped with Xalan-Java to direct output to two output
files.
Run this sample from the extensions subdirectory
with
java
org.apache.xalan.xslt.Process -in 1-redir.xml
-xsl
1-redir.xsl
The standard (non-redirected) output is written to the
screen. The redirected output is written to 1-redir-out, or
whatever filename you assign to the doc/foo @file attribute in
1-redir.xml. The stylesheet gets the file name for redirected
output from the XML input file.
|
|
|
What it does: Uses an extension element and extension
function implemented in JavaScript to compute a deadline for
responding to a customer inquiry.
 |
js.jar must be on the
classpath. |
Run this sample from the extensions subdirectory
with
java
org.apache.xalan.xslt.Process -in
2-basicJscript.xml
-xsl
2-basicJscript.xsl
|
|
|
What it does: Uses extension functions to format dates.
This sample illustrates use of the predefined java extension
namespace to provide ready access to extensions implemented in
Java.
Run this sample from the extensions subdirectory
with
java
org.apache.xalan.xslt.Process -in
3-java-namespace.xml
-xsl
3-java-namespace.xsl
|
|
|
What it does: Uses a Java extension to transform a set of
name elements into a numbered and alphabetized list.
Run this sample from the extensions subdirectory
with
java
org.apache.xalan.xslt.Process -in numlist.xml
-xsl
4-numlistJava.xsl
|
|
|
What it does: Uses a JavaScript extension to transform a
set of name elements into a numbered and alphabetized list. This
sample performs the same operations as the preceding Java
extension.
 |
js.jar must be on the
classpath. |
Run this sample from the extensions subdirectory
with
java
org.apache.xalan.xslt.Process -in numlist.xml
-xsl
5-numlistJscript.xsl
|
|
|
|
The SQL library extension enables you
to execute SQL queries from within a stylesheet, and to incorporate
query result sets in the XML output. To use the SQL library, you
need a JDBC driver, the underlying DBMS, and a database. Our
samples use Lutris® InstantDB. You can also customize the
stylesheets for your own database implementations.
|
|
 |
Except for
6-sqllib-instantdb, all these samples have been created by John
Gentilin (johnglinux@eyecatching.com) to illustrate the rich
feature set he has contributed to the SQL Library. To run each of
these samples, be sure you are in the appropriate extensions/sql
subdirectory. |
|
|
|
What it does: Uses the SQL library XConnection extension
to connect to the InstantDB sample database, performs a query, and
returns the query result in an HTML table.
Set up the database,
and run this sample from the extensions subdirectory:
java
org.apache.xalan.xslt.Process
-xsl
6-sqllib-instantdb.xsl -out import1.html
|
|
|
Contributed by John Gentilin
(johnglinux@eyecatching.com).
What it does: illustrates two strategies for connecting
to a database, executing a static query, and returning the query
result.
The first strategy is to get connection information along
with the static query from the stylesheet (dbtest.xsl)\ in the form
of stylesheet parameters.
The second strategy is to get connection information from
a nodeset in an XML source document (dbInfo.xml).
Set up the database,
and run this sample from the extensions/sql/basic-connection
directory.
1. To get connection information from the
stylesheet:
java
org.apache.xalan.xslt.Process
-xsl dbtest.xsl
-out import1.html
2. To get connection information in the form of a nodeset
from the XML source document:
java
org.apache.xalan.xslt.Process
-in dbinfo.xml
-xsl dbtest-cinfo.xsl
-out
import1.html
3. To get connection information from the stylesheet and
dump the raw result set to an XML file:
java
org.apache.xalan.xslt.Process
-xsl
DumpSQL.xsl -out import1.xml
|
|
|
Contributed by John Gentilin
(johnglinux@eyecatching.com).
What it does: The ExternalConnection classes uses the
default implementation of the ConnectionPool interface to create a
pool of connections. A stylesheet in turn uses a connection from
this pool to instantiate an XConnection object and connect to a
datasouce.
The stylesheet uses this named connection pool to
instantiate an XConnection object and connect to the datasource.
The ExternalConnection class is in xalansamples.jar.
Set up the database,
be sure xalanxamples.jar is on the class path, and run this sample
from the extensions/sql/ext-connection directory:
java
ExternalConnection
ExternalConnection creates the ConnectionPool, and
performs a transformation with dbtest.xsl, which draws from the
pool to instantiate an XConnection object, connect to the
datasource, execute a static query, and return the query
result.
|
|
|
Contributed by John Gentilin
(johnglinux@eyecatching.com).
What it does: connect to a datasource, execute a
parameterized query, and return the result. The XML source document
provides the parameter value as well as the connection information.
The parameter value is in a node in the XML source.
The stylesheet gets the required connection and parameter
information from the XML source, sets up and executes the
parameterized query, and retuns the query result set.
Set up the database,
and run this sample from the sql/pquery subdirectory:
java
org.apache.xalan.xslt.Process -in dbInfo.xml
-xsl dbTest.xsl -out
dbTest.html
|
|
|
Contributed by John Gentilin
(johnglinux@eyecatching.com).
What it does: Illustrates enabling and disabling of
caching the streamable result set returned by a query.
The stylesheets use the XConnection enableCacheNodes()
and disableCacheNodes() methods.
Set up the database,
and run these samples from the sql/streamable
subdirectory.
1. To turn caching on:
java
org.apache.xalan.xslt.Process
-xsl
cachedNodes.xsl
1. To turn caching off:
java
org.apache.xalan.xslt.Process
-xsl
streamNodes.xsl
3. To be added
|
|
|
|
What it
does: Trace uses the TraceListener and TraceManager classes to log
transformation events.
Run this
sample from the Trace subdirectory with
java Trace
and
examine the result in events.log. For more information, see Debugger
Interface
|
|
|
|
|
What it does: Uses
SAXParserFactory to turn on validation, and
XMLReader to parse the XML input and report errors and warnings
to a SAX event handler. The XML input (birds.xml) contains an
internal DOCTYPE declaration, and a few minor document type
violations, which you are invited to fix, add to, and vary in any
way you find useful.
Run this sample from the Validate subdirectory
with
java
ValidateXMLInput
|
|
|
What it does: Uses the
JAXP SAXParser with a SAX event handler (extends
DefaultHandler and implements
LexicalHandler) to verify that XML files conform to their
declared document type. You can use this utility to verify that an
individual file or all the .xml files in a directory are
well-formed and valid. Each .xml file should contain a DOCTYPE
declaration.
Run this sample from any directory with
java Validate
file-or-dir-name [logfile ]
where file-or-dir-name is an XML file or directory
pathname, and logfile designates a log. If you omit the
second argument, Validate reports its findings to the
screen.
 |
A limitation: Files
containing document parts appear to fail if you check them with
Validate. Check readme.xml, which "includes" by entity reference a
number of files, and it passes. The parse operation scans the
entire document with the includes. Check an "included" file (such
as history.xml) as if it were an independent document and it
fails. |
|
|
|
|
What it
does: run a number of samples illustrating uses of the TRaX (Transformation API for XML)
interfaces.
Run this
sample from the trax subdirectory with
java Examples
and
examine the source in Examples.java and
ExampleContentHandler.java.
|
|
|
You can
use the TrAX/JAXP 1.2 interfaces to compile and run translets. For
this release, you must still use StreamSource objects for the XSL
stylesheet and XML input document, and a StreamResult object for
the transformation output. For an overview of the usage patterns
these samples illustrate, see Calling XSLTC with the TrAX/JAXP
API.
Important: To run these
samples, you must compile the sample class files and adjust the
system classpath.
- To
compile the samples, you can run the Ant build from the root
directory as follows:
build
xsltc.samples
- Add
xsltc.jar, runtime.jar, BCEL.jar, java_cup.jar, and the
samples/translets subdirectory to the classpath
 |
The JAR files listed
above are in the bin directory. The samples/translets directory
contains the sample class files as well as the translet class file
that is generated at tun time (todo.class from the todo.xsl
stylesheet). |
|
|
Other XSLTC samples are located in the following samples
subdirectories:
- CompiledServlet
- CompiledBrazil
- CompiledJAXP
- CompiledApplet
- CompiledEJB
For information about each of these samples, consult the
README file in the subdirectory.
 |
The following
paragraphs supply some basic background information for
CompiledServlet and CompiledBrazil. |
XSLTC provides demos for using XSLTC as a servlet and as
a handler for Brazil (a new and powerful Web techology from Sun
labs).
To run the Brazil-handler demo, download Brazil from
sunlabs:
http://research.sun.com/research/download/index.html
The translet must be specified as a pure class name,
accessible through the Brazil-handler's classpath. For
example:
translet=mk054
The document must be specified as a valid URL. For
example:
document=http://server/path/to/filename.xml
If the file is local to the Brazil handler, it has to be
specified using the "file:filename.xml" format.
 |
In order to run the
Brazil-handler demo, you also need to make the Brazil and javax
classes available from your classpath |
To run the servlet demo, download the java extensions for
servlets from Sun:
http://java.sun.com/products/servlet/download.html
|
|
|