Santi Caltabiano

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

Santi Caltabiano

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

Santi Caltabiano

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!!

Santi Caltabiano

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).

Santi Caltabiano

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).

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

Santi Caltabiano

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 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.

Santi Caltabiano

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

Santi Caltabiano

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 Generate dynamic documents from XML files or databases

Santi Caltabiano

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 serialization utilities

Santi Caltabiano

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.

Santi Caltabiano

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 è completamente open source. L’ultima versione, comprensiva di codice sorgente e documentazione, è reperibile all’indirizzo http://jakarta.apache.org/log4j.

Santi Caltabiano

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.

Santi Caltabiano

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 JavaTM (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.

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.

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.

Santi Caltabiano

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_1-bin.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 xalan-j_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.