Jasper report dependencies [by sc]

1. JasperReport Libraries
JasperReport Libraries..........................................................................................................................1
Apache ANT (ant.apache.org)..........................................................................................................2
ANTLR (www.antlr.org)..................................................................................................................2
barbecue (http://barbecue.sourceforge.net).....................................................................................2
batik (http://xmlgraphics.apache.org/batik).....................................................................................2
Apache BCEL (http://jakarta.apache.org/bcel)................................................................................2
Beanshell (abbrev. bsh) (http://www.beanshell.org)........................................................................3
Apache Commons beanutils (http://commons.apache.org/beanutils)..............................................4
Apache Commons Collections (http://commons.apache.org/collections/).......................................5
Apache Commons digester (http://commons.apache.org/digester)..................................................6
Apache Common javaflow (http://commons.apache.org/sandbox/javaflow).................................6
Apache Commons logging (http://commons.apache.org/logging)...................................................7
groovy (http://groovy.codehaus.org)................................................................................................7
hibernate (https://www.hibernate.org)..............................................................................................8
HyperSQL (abbrev. HSQLDB) (http://hsqldb.org)..........................................................................8
iText PDF (http://itextpdf.com)........................................................................................................8
jaxen (http://jaxen.codehaus.org).....................................................................................................9
jcommon (http://www.jfree.org/jcommon)......................................................................................9
JDT Compiler (http://www.eclipse.org/jdt/core/index.php)..........................................................10
jfreechart (http://www.jfree.org/jfreechart)....................................................................................10
Java Persistence API (JPA) (http://java.sun.com/javaee/technologies/persistence.jsp).................11
Java Excel API (abbrev. jexcelapi) (http://jexcelapi.sourceforge.net)...........................................11
Some Features ...........................................................................................................................11
Apache log4j (http://logging.apache.org/log4j)............................................................................11
mondrian (http://sourceforge.net/projects/mondrian).....................................................................12
pngencoder (http://catcode.com/pngencoder)................................................................................12
Apache POI (http://poi.apache.org)................................................................................................12
Rhino: Javascript for java (http://www.mozilla.org/rhino)............................................................13
Saaj (https://saaj.dev.java.net)........................................................................................................13
Spring (http://www.springsource.org)............................................................................................13
Apache xalan (http://xml.apache.org/xalan-j)................................................................................13
Apache xerces (http://xerces.apache.org/xerces2-j).......................................................................13
Apache xml api (http://xml.apache.org/xalan-j/downloads.html)..................................................14

2. Apache ANT (ant.apache.org)
JasperReports comes bundled with some custom ANT targets for previewing report designs and for
viewing reports serialized in JasperReports' native format. Although not mandatory, it is very
helpful to have ANT available to take advantage of these custom targets. Throughout this book, we
will be using JasperReports-specific ANT targets. Therefore, ANT is required when following the
examples. ANT can be downloaded from http://ant.apache.org/.
ANTLR (www.antlr.org)
What is ANTLR? ANTLR, ANother Tool for Language Recognition, is a language tool that
provides a framework for constructing recognizers, interpreters, compilers, and translators
from grammatical descriptions containing actions in a variety of target languages. ANTLR
provides excellent support for tree construction, tree walking, translation, error recovery,
and error reporting. There are currently about 5,000 ANTLR source downloads a month.
barbecue (http://barbecue.sourceforge.net)
Barbecue is an open-source, Java library that provides the means to create
barcodes for printing and display in Java applications. A number of barcode
formats are supported and many more can be added via the flexible barcode
API. Barcodes can be output to three different image formats (PNG, GIF,
JPEG), used as a Swing component, or written out as SVG.
batik (http://xmlgraphics.apache.org/batik)
Batik is a Java-based toolkit for applications or applets that want to use images
in the Scalable Vector Graphics (SVG) format for various purposes, such as
display, generation or manipulation. The project’s ambition is to give
developers a set of core modules that can be used together or individually to
support specific SVG solutions. Examples of modules are the SVG Parser, the
SVG Generator and the SVG DOM. Another ambition for the Batik project is to
make it highly extensible—for example, Batik allows the developer to handle
custom SVG elements. Even though the goal of the project is to provide a set
of core modules, one of the deliverables is a full fledged SVG browser
implementation which validates the various modules and their inter-operability.
Apache BCEL (http://jakarta.apache.org/bcel)
The Byte Code Engineering Library is intended to give users a convenient
possibility to analyze, create, and manipulate (binary) Java class files (those
ending with .class). Classes are represented by objects which contain all the

3. symbolic information of the given class: methods, fields and byte code
instructions, in particular.
Such objects can be read from an existing file, be transformed by a program
(e.g. a class loader at run-time) and dumped to a file again. An even more
interesting application is the creation of classes from scratch at run-time.
The Byte Code Engineering Library (BCEL) may be also useful if you want to
learn about the Java Virtual Machine (JVM) and the format of Java .class
files.
BCEL contains a byte code verifier named JustIce, which usually gives you
much better information about what's wrong with your code than the
standard JVM message.
BCEL is already being used successfully in several projects such as compilers,
optimizers, obsfuscators, code generators and analysis tools. Unfortunately
there hasn't been much development going on over the past few years. Feel
free to help out or you might want to have a look into the ASM project at
objectweb.
Beanshell (abbrev. bsh) (http://www.beanshell.org)
BeanShell
is a small, free, embeddable Java source interpreter with object scripting language
features, written in Java. BeanShell dynamically executes standard Java syntax and extends it with
common scripting conveniences such as loose types, commands, and method closures like those in
Perl and JavaScript.
You can use BeanShell interactively for Java experimentation and debugging as well as to extend
your applications in new ways. Scripting Java lends itself to a wide variety of applications including
rapid prototyping, user scripting extension, rules engines, configuration, testing, dynamic
deployment, embedded systems, and even Java education.
BeanShell is small and embeddable, so you can call BeanShell from your Java applications to
execute Java code dynamically at run-time or to provide extensibility in your applications.
Alternatively, you can use standalone BeanShell scripts to manipulate Java applications; working
with Java objects and APIs dynamically. Since BeanShell is written in Java and runs in the same
VM as your application, you can freely pass references to "live" objects into scripts and return them
as results.
In short, BeanShell is dynamically interpreted Java, plus a scripting language and flexible
environment all rolled into one clean package.
Summary of features
•
•
•
•
•
•
•
Dynamic execution of the full Java syntax, Java code fragments, as well as loosely typed
Java and additional scripting conveniences.
Transparent access to all Java objects and APIs.
Runs in four modes: Command Line, Console, Applet, Remote Session Server.
Can work in security constrained environments without a classloader or bytecode generation
for most features.
The interpreter is small ~150K jar file.
Pure Java.
It's Free!!

4. Java evaluation features:
•
Evaluate full Java source classes dynamically as well as isolated Java methods, statements,
and expressions.
Scripting features:
•
•
•
•
•
•
•
•
•
•
•
Optionally typed variables.
Scripted methods with optionally typed arguments and return values
Scripted objects (method closures)
Scripted interfaces and event handlers.
Convenience syntax for working with JavaBean properties, hashtables, and primitive
wrapper types.
Auto-allocation of variables to emulate Java properties files.
Extensible set of utility and shell-like commands
Dynamic classpath management including find grained class reloading
Dynamic command loading and user command path
Sophisticated namespace and callstack management
Detailed error reporting
BeanShell Uses
•
•
•
•
•
•
•
Interactive Java - try out object features, APIs and GUI widgets - "hands on".
Scripting extension for applications - Allow your applications to be extended via scripts in
an intuitive and simple way.
Macro Languages - Generate scripts as macros and execute them live in your VM easily.
Education - Teach Java in a hands-on, live environment
Expression evaluator for scientific, financial apps and rules engines - evaluate complex
expressions with conditions and loops.
Remote debugging - Embed a live, remotely accessible shell / command line in your
application with just a few lines of code.
Use BeanShell declaratively to replace properties files and replace startup config files with
real scripts that perform complex initialization and setup with the full Java syntax at their
disposal.
Apache Commons beanutils (http://commons.apache.org/beanutils)
Most Java developers are used to creating Java classes that conform to the
JavaBeans naming patterns for property getters and setters. It is natural to
then access these methods directly, using calls to the corresponding getXxx
and setXxx methods. However, there are some occasions where dynamic
access to Java object properties (without compiled-in knowledge of the
property getter and setter methods to be called) is needed. Example use
cases include:
• Building scripting languages that interact with the Java object model
(such as the Bean Scripting Framework).
• Building template language processors for web presentation and similar
uses (such as JSP or Velocity).
• Building custom tag libraries for JSP and XSP environments (such as
Jakarta Taglibs, Struts, Cocoon).

5. •
Consuming XML-based configuration resources (such as Ant build scripts,
web application deployment descriptors, Tomcat's server.xml file).
The Java language provides Reflection and Introspection APIs (see the
java.lang.reflect and java.beans packages in the JDK Javadocs).
However, these APIs can be quite complex to understand and utilize. The
BeanUtils component provides easy-to-use wrappers around these
capabilities.
Since the 1.7.0 release BeanUtils has distributed three jars:
• commons-beanutils.jar - contains everything
• commons-beanutils-core.jar - excludes Bean Collections classes
• commons-beanutils-bean-collections.jar - only Bean Collections
classes
The main commons-beanutils.jar has an optional dependency on Commons
Collections
Apache Commons Collections (http://commons.apache.org/collections/)
The Java Collections Framework was a major addition in JDK 1.2. It added
many powerful data structures that accelerate development of most
significant Java applications. Since that time it has become the recognised
standard for collection handling in Java.
Commons-Collections seek to build upon the JDK classes by providing new
interfaces, implementations and utilities. There are many features, including:
• Bag interface for collections that have a number of copies of each object
• Buffer interface for collections that have a well defined removal order,
like FIFOs
• BidiMap interface for maps that can be looked up from value to key as
well and key to value
• MapIterator interface to provide simple and quick iteration over maps
• Type checking decorators to ensure that only instances of a certain type
can be added
• Transforming decorators that alter each object as it is added to the
collection
• Composite collections that make multiple collections look like one
• Ordered maps and sets that retain the order elements are added in,
including an LRU based map
• Identity map that compares objects based on their identity (==) instead
of the equals method
• Reference map that allows keys and/or values to be garbage collected
under close control
• Many comparator implementations
• Many iterator implementations
• Adapter classes from array and enumerations to collections

6. •
Utilities to test or create typical set-theory properties of collections such
as union, intersection, and closure
Apache Commons digester (http://commons.apache.org/digester)
Many projects read XML configuration files to provide initialization of various
Java objects within the system. There are several ways of doing this, and the
Digester component was designed to provide a common implementation that
can be used in many different projects.
Basically, the Digester package lets you configure an XML -> Java object
mapping module, which triggers certain actions called rules whenever a
particular pattern of nested XML elements is recognized. A rich set of
predefined rules is available for your use, or you can also create your own.
Advanced features of Digester include:
• Ability to plug in your own pattern matching engine, if the standard one
is not sufficient for your requirements.
• Optional namespace-aware processing, so that you can define rules that
are relevant only to a particular XML namespace.
• Encapsulation of Rules into RuleSets that can be easily and conveniently
reused in more than one application that requires the same type of
processing.
Apache Common javaflow
(http://commons.apache.org/sandbox/javaflow)
Sometimes it is usefull if we can capture the state of the application, its stack
of function calls, which includes local variables, the global variables and the
program counter, and save them into an object. If this object would give us
the ability to restart the processing from the point stored in it.
A continuation is exactly the type of object that we need. Think of a
continuation as an object that, for a given point in your program, contains a
snapshot of the stack trace, including all the local variables, and the program
counter. You can not only store these things in the continuation object, but
also restore the execution of the program from a continuation object. This
means that the stack trace and the program counter of the running program
become the ones stored in a continuation.
Continuations are powerful concepts from the world of functional languages,
like Scheme, but they are becoming popular in other languages as well.

7. Apache Commons logging (http://commons.apache.org/logging)
When writing a library it is very useful to log information. However there are
many logging implementations out there, and a library cannot impose the use
of a particular one on the overall application that the library is a part of.
The Logging package is an ultra-thin bridge between different logging
implementations. A library that uses the commons-logging API can be used
with any logging implementation at runtime. Commons-logging comes with
support for a number of popular logging implementations, and writing
adapters for others is a reasonably simple task.
Applications (rather than libraries) may also choose to use commons-logging.
While logging-implementation independence is not as important for
applications as it is for libraries, using commons-logging does allow the
application to change to a different logging implementation without
recompiling code.
Note that commons-logging does not attempt to initialise or terminate the
underlying logging implementation that is used at runtime; that is the
responsibility of the application. However many popular logging
implementations do automatically initialise themselves; in this case an
application may be able to avoid containing any code that is specific to the
logging implementation used.
groovy (http://groovy.codehaus.org)
What’s groovy?
•
is an agile and dynamic language for the Java Virtual Machine
•
builds upon the strengths of Java but has additional power features inspired by
languages like Python, Ruby and Smalltalk
•
makes modern programming features available to Java developers with
almost-zero learning curve
•
supports Domain-Specific Languages and other compact syntax so your code
becomes easy to read and maintain
•
makes writing shell and build scripts easy with its powerful processing
primitives, OO abilities and an Ant DSL
•
increases developer productivity by reducing scaffolding code when developing
web, GUI, database or console applications
•
simplifies testing by supporting unit testing and mocking out-of-the-box
•
seamlessly integrates with all existing Java objects and libraries
•
compiles straight to Java bytecode so you can use it anywhere you can use Java

8. hibernate (https://www.hibernate.org)
Hibernate is a powerful, high performance object/relational persistence and query service.
Hibernate lets you develop persistent classes following object-oriented idiom - including
association, inheritance, polymorphism, composition, and collections. Hibernate allows you
to express queries in its own portable SQL extension (HQL), as well as in native SQL, or
with an object-oriented Criteria and Example API.
Unlike many other persistence solutions, Hibernate does not hide the power of SQL from
you and guarantees that your investment in relational technology and knowledge is as
valid as always. The LGPL open source license allows the use of Hibernate and
NHibernate in open source and commercial projects.
Hibernate is a Professional Open Source project and a critical component of the JBoss
Enterprise Middleware System (JEMS) suite of products. JBoss, a division of Red Hat,
offers a range of 24x7 Professional Support, Consulting, and Training services to assist
you with Hibernate.
HyperSQL (abbrev. HSQLDB) (http://hsqldb.org)
Version 2.0 supports the widest range of SQL Standard features seen in any open source database
engine. We have reached SQL Standard conformance to almost full SQL-1992 Advanced Level and
SQL:2008 core language features and support an extensive list of SQL:2008 optional features plus
many extensions. The engine is fully multithreaded and supports 2PL and MVCC transaction
control models. See the list of new features in version 2.0. Please test this version and report any
issues you find. Download available from the file download page. A more recent snapshot jar with
the latest bug fixes is available from the support page.
iText PDF (http://itextpdf.com)
iText is a library that allows you to generate PDF files on the fly.
iText is an ideal library for developers looking to enhance web- and other applications with
dynamic PDF document generation and/or manipulation. iText is not an end-user tool.
Typically you won't use it on your Desktop as you would use Acrobat or any other PDF
application. Rather, you'll build iText into your own applications so that you can automate
the PDF creation and manipulation process. For instance in one or more of the following
situations:
•
•
•
•
•
Due to time or size, the PDF documents can't be produced manually.
The content of the document must be calculated or based on user input.
The content needs to be customized or personalized.
The PDF content needs to be served in a web environment.
Documents are to be created in "batch process" mode.
You can use iText to:
•
Serve PDF to a browser

9. •
•
•
•
•
•
•
Generate dynamic documents from XML files or databases
Use PDF's many interactive features
Add bookmarks, page numbers, watermarks, etc.
Split, concatenate, and manipulate PDF pages
Automate filling out of PDF forms
Add digital signatures to a PDF file
And much more...
In short: the iText classes are very useful for people who need to generate read-only,
platform independent documents containing text, lists, tables and images; or who want to
perform specific manipulations on existing PDF documents. The library is especially useful
in combination with Java(TM) technology-based Servlets; there's also a .NET port available:
iTextSharp (written in C#).
iText requires Java 5. It's available for free under the GNU Affero General Public License
(see the Terms of Use).
Technical Requirements
If you want to use the iText classes you should be acquainted with JAVA (TM)
programming.
You'll also need the following Software:
•
•
The Java Development Kit (JDK) 1.5 (or any later version) from Sun Microsystems
Incorporated.
The BouncyCastle: bcprov, bcmail, and bctsp
A good place to start learning how to use iText is the book iText in Action - 2nd Edition.
jaxen (http://jaxen.codehaus.org)
Jaxen is an open source XPath library written in Java. It is adaptable to many
different object models, including DOM, XOM, dom4j, and JDOM. Is it also
possible to write adapters that treat non-XML trees such as compiled Java byte
code or Java beans as XML, thus enabling you to query these trees with XPath
too.
jcommon (http://www.jfree.org/jcommon)
JCommon is a Java class library that is used by JFreeChart, Pentaho Reporting and a few other
projects. The library contains miscellaneous classes that support:
•
•
•
•
•
•
configuration and dependency management code
a general logging framework
text utilities
user interface classes for displaying information about applications
custom layout managers
a date chooser panel

10. •
serialization utilities
JCommon is licensed under the terms of the GNU Lesser General Public Licence (LGPL) version
2.1 or later.
Note that JCommon is being maintained but not actively developed and in the future will be
dropped as a dependency for both JFreeChart and Pentaho Reporting.
JDT Compiler (http://www.eclipse.org/jdt/core/index.php)
JDT stands for Java Development Tools. The JDT compiler is the Java compiler included with the
Eclipse IDE (Integrated Development Environment). The JDT compiler is needed only when the
JasperReports application is running under a Java Runtime Environment (JRE), and not under a full
JDK.
When compiling reports, JasperReports creates temporary Java files and compiles them. When
using a JDK, JasperReports takes advantage of tools.jar for this functionality. Since a JRE
does not include tools.jar, the JDT compiler is needed. The JasperReports project ZIP file
version 1.2.2 includes the JDT compiler. It can be found under the lib subdirectory of the
directory created when extracting the project ZIP file. The file to be added to your CLASSPATH is
jdt-compiler.jar.
This file cannot be downloaded separately. Therefore, if we need to execute our code under a JRE,
we need to download the JasperReports project ZIP file, since it includes the file, which is needed
for report compilation.
JasperReports requires either tools.jar or the JDT when compiling JRXML templates into
binary JasperReports templates. A JRE is sufficient if our Java application does not compile reports.
jfreechart (http://www.jfree.org/jfreechart)
JFreeChart is a free 100% Java chart library that makes it easy for developers to display
professional quality charts in their applications. JFreeChart's extensive feature set includes:
•
•
•
•
a consistent and well-documented API, supporting a wide range of chart types;
a flexible design that is easy to extend, and targets both server-side and client-side
applications;
support for many output types, including Swing components, image files (including PNG
and JPEG), and vector graphics file formats (including PDF, EPS and SVG);
JFreeChart is "open source" or, more specifically, free software. It is distributed under the
terms of the GNU Lesser General Public Licence (LGPL), which permits use in proprietary
applications.
For a closer look at JFreeChart, please try our JFreeChart Demo (web start) or browse the Samples
page.

11. Java Persistence API (JPA)
(http://java.sun.com/javaee/technologies/persistence.jsp)
The Java Persistence API provides a POJO persistence model for object-relational mapping. The
Java Persistence API was developed by the EJB 3.0 software expert group as part of JSR 220, but
its use is not limited to EJB software components. It can also be used directly by web applications
and application clients, and even outside the Java EE platform, for example, in Java SE
applications. See JSR 220.
Java Excel API (abbrev. jexcelapi) (http://jexcelapi.sourceforge.net)
Java Excel API is a mature, open source java API enabling developers to read,
write, and modifiy Excel spreadsheets dynamically. Now java developers can
read Excel spreadsheets, modify them with a convenient and simple API, and
write the changes to any output stream (e.g. disk, HTTP, database, or any
socket).
Any operating system which can run a Java virtual machine (i.e., not just
Windows) can both process and deliver Excel spreadsheets. Because it is Java,
the API can be invoked from within a servlet, thus giving access to Excel
spreadsheets over internet and intranet web applications.
Some Features
 Reads data from Excel 95, 97, 2000, XP, and 2003 workbooks
 Reads and writes formulas (Excel 97 and later only)
 Generates spreadsheets in Excel 2000 format
 Supports font, number and date formatting
 Supports shading, bordering, and coloring of cells
 Modifies existing worksheets
 Is internationalized, enabling processing in almost any locale, country,
language, or character encoding (formulas are currently only supported in
English, French, Spanish, and German, but more can be added if translated)
 Supports copying of charts
 Supports insertion and copying of images into spreadsheets
 Supports logging with Jakarta Commons Logging, log4j, JDK 1.4 Logger,
etc
 ...and much more
Apache log4j (http://logging.apache.org/log4j)
Log4j è un framework che permette di utilizzare il meccanismo dei log all'interno di
un’applicazione in modo semplice, potente ed elegante. Il log è un’informazione che può essere
utilizzata per effettuare un’analisi in caso di errore, per il ripristino di situazioni precedenti, per
verificare se alcune operazioni sono state eseguite e da chi o cosa, o più in generale, per riassumere
quanto accaduto in un determinato arco temporale. Log4j è divenuto il più popolare sistema di
logging tra gli sviluppatori Java (è disponibile anche per C, C++, C#, Perl, Python, …) ed è
compatibile a partire dalla JDK 1.1.x.È distribuito sotto licenza della Apache Fundation ed è

12. completamente open source. L’ultima versione, comprensiva di codice sorgente e documentazione,
è reperibile all’indirizzo http://jakarta.apache.org/log4j.
mondrian (http://sourceforge.net/projects/mondrian)
Mondrian is an OLAP (online analytical processing) engine written in Java. It reads from
JDBC data sources, aggregates data in a memory cache, and implements the MDX
language and the olap4j and XML/A APIs.
pngencoder (http://catcode.com/pngencoder)
The PngEncoder class takes a Java Image as its input and produces a byte array in PNG format.
This array can be saved in a file or sent to a client by a servlet.
Apache POI (http://poi.apache.org)
The Apache POI Project's mission is to create and maintain Java APIs for
manipulating various file formats based upon the Office Open XML standards
(OOXML) and Microsoft's OLE 2 Compound Document format (OLE2). In
short, you can read and write MS Excel files using Java. In addition, you can
read and write MS Word and MS PowerPoint files using Java. Apache POI is
your Java Excel solution (for Excel 97-2008). We have a complete API for
porting other OOXML and OLE2 formats and welcome others to participate.
OLE2 files include most Microsoft Office files such as XLS, DOC, and PPT as
well as MFC serialization API based file formats. The project provides APIs for
the OLE2 Filesystem (POIFS) and OLE2 Document Properties (HPSF).
Office OpenXML Format is the new standards based XML file format found in
Microsoft Office 2007 and 2008. This includes XLSX, DOCX and PPTX. The
project provides a low level API to support the Open Packaging Conventions
using openxml4j.
For each MS Office application there exists a component module that
attempts to provide a common high level Java api to both OLE2 and OOXML
document formats. This is most developed for Excel workbooks
(SS=HSSF+XSSF). Work is progressing for Word documents (HWPF+XWPF)
and PowerPoint presentations (HSLF+XSLF).
The project has recently added support for Outlook (HSMF). Microsoft opened
the specifications to this format in October 2007. We would welcome
contributions.
There are also projects for Visio (HDGF) and Publisher (HPBF).
As a general policy we collaborate as much as possible with other projects to
provide this functionality. Examples include: Cocoon for which there are
serializers for HSSF; Open Office.org with whom we collaborate in
documenting the XLS format; and Lucene for which we provide format
interpretors. When practical, we donate components directly to those
projects for POI-enabling them.

13. Rhino: Javascript for java (http://www.mozilla.org/rhino)
Rhino is an open-source implementation of JavaScript written entirely in Java. It is typically
embedded into Java applications to provide scripting to end users.
Saaj (https://saaj.dev.java.net)
The SOAP with Attachments API for Java (SAAJ) 1.3 provides the API for creating and sending
SOAP messages by means of the javax.xml.soap package. It is used for the SOAP messaging that
goes on behind the scenes in JAX-RPC, and JAXR implementations. SOAP Handlers in JAX-WS
use SAAJ APIs to access the SOAP Message. Developers can also use it to write SOAP messaging
applications directly instead of using JAX-RPC/JAX-WS.
TM
Spring (http://www.springsource.org)
Librerie da utilizza in combinazione con spring framework.
Apache xalan (http://xml.apache.org/xalan-j)
Xalan-Java is an XSLT processor for transforming XML documents into HTML, text, or
other XML document types. It implements XSL Transformations (XSLT) Version 1.0 and
XML Path Language (XPath) Version 1.0 and can be used from the command line, in an
applet or a servlet, or as a module in other program.
Xalan-Java implements the javax.xml.transform interface in Java API for XML Processing
(JAXP) 1.3. This interface provides a modular framework and a standard API for
performing XML transformations, and utilizes system properties to determine which
Transformer and which XML parser to use.
Xalan-Java also implements the javax.xml.xpath interface in JAXP 1.3, which provides an
object-model neutral API for evaluation of XPath expressions and access to the evaluation
environment.
Xalan-Java also builds on SAX 2 and DOM level 3.
Apache xerces (http://xerces.apache.org/xerces2-j)
Welcome to the future! Xerces2 is the next generation of high performance, fully compliant
XML parsers in the Apache Xerces family. This new version of Xerces introduces the
Xerces Native Interface (XNI), a complete framework for building parser components and
configurations that is extremely modular and easy to program.

14. The Apache Xerces2 parser is the reference implementation of XNI but other parser
components, configurations, and parsers can be written using the Xerces Native Interface.
For complete design and implementation documents, refer to the XNI Manual.
Xerces2 is a fully conforming XML Schema processor. For more information, refer to the
XML Schema page.
Xerces2 also provides a complete implementation of the Document Object Model Level 3
Core and Load/Save W3C Recommendations and provides a complete implementation of
the XML Inclusions (XInclude) W3C Recommendation. It also provides support for OASIS
XML Catalogs v1.1.
Xerces2 is able to parse documents written according to the XML 1.1 Recommendation,
except that it does not yet provide an option to enable normalization checking as described
in section 2.13 of this specification. It also handles namespaces according to the XML
Namespaces 1.1 Recommendation, and will correctly serialize XML 1.1 documents if the
DOM level 3 load/save APIs are in use.
Apache xml api (http://xml.apache.org/xalan-j/downloads.html)
Xalan-J has two processors, an interpretive one, Xalan Interpretive, and a compiled one,
Xalan Compiled (XSLTC). Your choice of which binary distribution to download depends
on which of the processors you want to use. There are 2 binary distributions available; you
only need to choose one of them. Both binary distributions contain xml-apis.jar and
xercesImpl.jar from Xerces-Java 2.9.0.
•
The first binary distribution, xalan-j_2_7_1-bin.zip or xalan-j_2_7_1bin.tar.gz, contains the Xalan Interpretive processor, the Xalan Compiled
processor (XSLTC) and the runtime support packages in a single jar, called
xalan.jar. The reason to use this distribution would be that you don't know which
processor you are going to use, or might be using both.
•
The second binary distribution, xalan-j_2_7_1-bin-2jars.zip or xalanj_2_7_1-bin-2jars.tar.gz contains the Xalan Interpretive processor in
xalan.jar, and the Xalan Compiled processor (XSLTC) and the runtime support
packages in xsltc.jar. The reason to using this distribution is that you want more
control. If you are using just XSLTC you can put xsltc.jar on the classpath and
not xalan.jar. If you are using just the interpretive processor you can put xalan
xalan.jar on the classpath and not xsltc.jar. Of course you can put both
xalan.jar and xsltc.jar from this distribution on your classpath if you want to
use both.