Commons Compress is a component that contains Tar, Zip and BZip2
packages.

The Daemon Component contains a set of Java and native code, including
a set of Java interfaces applications must implement and Unix native
code to control a Java daemon from a Unix operating system.

The DBCP package creates and maintains a database connection pool
package written in the Java language to be distributed under the ASF
license. The package is available as a pseudo-JDBC driver and via a
DataSource interface. The package also supports multiple logins to
multiple database systems, reclamation of stale or dead connections,
testing for valid connections, PreparedStatement pooling, and other
features.

The goal of the Jakarta Commons Digester project is to create and
maintain an XML to Java object mapping package written in the Java
language to be distributed under the ASF license.

The Discovery component is about discovering, or finding,
implementations for pluggable interfaces. Pluggable interfaces are
specified with the intent that multiple implementations are, or will
be, available to provide the service described by the interface.
Discovery provides facilities for finding and instantiating classes and
for lifecycle management of singleton (factory) classes.

An implementation of standard interfaces and abstract classes for
javax.servlet.jsp.el, which is part of the JSP 2.0 specification.

The javax.servlet package lacks support for RFC 1867, HTML file upload.
This package provides a simple-to-use API for working with such data.
The scope of this package is to create a package of Java utility
classes to read multipart/form-data within a
javax.servlet.http.HttpServletRequest.

Although the java.net package provides basic functionality for
accessing resources via HTTP, it doesn't provide the full flexibility
or functionality needed by many applications. The Jakarta Commons
HttpClient component seeks to fill this void by providing an efficient,
up-to-date, and feature-rich package implementing the client side of
the most recent HTTP standards and recommendations.

Designed for extension while providing robust support for the base HTTP
protocol, the HttpClient component may be of interest to anyone
building HTTP-aware client applications such as web browsers, web
service clients, or systems that leverage or extend the HTTP protocol
for distributed communication.

Commons-IO contains utility classes, stream implementations, file
filters, and endian classes.

The standard Java libraries fail to provide enough methods for
manipulation of its core classes. The Commons Lang Component provides
these extra methods.

The Commons Lang Component provides a host of helper utilities for the
java.lang API, notably String manipulation methods, basic numerical
methods, object reflection, creation and serialization, and System
properties. Additionally it contains an inheritable enum type, an
exception structure that supports multiple types of nested-Exceptions
and a series of utilities dedicated to help with building methods, such
as hashCode, toString and equals.

Commons-launcher eliminates the need for a batch or shell script to
launch a Java class. Some situations where elimination of a batch or
shell script may be desirable are:

* You want to avoid having to determining where certain application
paths are, for example, your application's home directory.
Determining this dynamically in a Windows batch scripts is very
tricky on some versions of Windows or when softlinks are used on
Unix platforms.

* You want to avoid having to handle native file and path separators
or native path quoting issues.

* You need to enforce certain system properties, such as
java.endorsed.dirs when running with JDK 1.4.

* You want to allow users to pass custom JVM arguments or system
properties without having to parse and reorder arguments in your
script. This can be tricky or messy in batch and shell scripts.

* You want to bootstrap system properties from a configuration file
instead hard-coding them in your batch and shell scripts.

* You want to provide localized error messages, which is very tricky to
do in batch and shell scripts.

The commons-logging package provides a simple, component oriented
interface (org.apache.commons.logging.Log) together with wrappers for
logging systems. The user can choose at runtime which system they want
to use. In addition, a small number of basic implementations are
provided to allow users to use the package independently.
commons-logging was heavily influenced by Avalon's Logkit and Log4J.
The commons-logging abstraction is meant to minimize the differences
between the two and to allow a developer to not tie himself to a
particular logging implementation.

The Modeler project creates and maintains a set of Java classes to
provide a number of facilities for Model MBeans plus unit tests and
small examples of using these facilities to instrument Java classes
with Model MBean support.

This is an Internet protocol suite Java library originally developed by
ORO, Inc. This version supports Finger, Whois, TFTP, Telnet, POP3,
FTP, NNTP, SMTP, and some miscellaneous protocols like Time and Echo as
well as BSD R command support. The purpose of the library is to provide
fundamental protocol access, not higher-level abstractions.

Commons Parent.

The goal of the Pool package is to create and maintain an object
(instance) pooling package to be distributed under the ASF license. The
package supports a variety of pool implementations, but encourages
support of an interface that makes these implementations
interchangeable.

Commons Transaction aims at providing lightweight, standardized, well
tested and efficient implementations of utility classes commonly used
in transactional Java programming. Initially there are implementations
for multi level locks, transactional collections and transactional file
access. There may be additional implementations when the common need
for them becomes obvious. However, the complete component shall remain
compatible to JDK1.2 and should have minimal dependencies.

A common issue when receiving data either electronically or from user
input is verifying the integrity of the data. This work is repetitive
and becomes even more complicated when different sets of validation
rules need to be applied to the same set of data based, for example, on
locale. Error messages may also vary by locale. This package attempts
to address some of these issues and speed development and maintenance
of validation rules.

Commons VFS provides a single API for accessing various different
file systems. It presents a uniform view of the files from
various different sources, such as the files on local disk, on an
HTTP server, or inside a Zip archive. Some of the features of
Commons VFS are: * A single consistent API for accessing files of
different types.

* Support for numerous file system types.

* Caching of file information. Caches information in-JVM, and
optionally can cache remote file information on the local file
system.

* Event delivery.

* Support for logical file systems made up of files from various
different file systems.

* Utilities for integrating Commons VFS into applications, such as a
VFS-aware ClassLoader and URLStreamHandlerFactory.

* A set of VFS-enabled Ant tasks.

The POI project consists of APIs for manipulating various file formats
based upon Microsoft's OLE 2 Compound Document format using pure Java.
In short, you can read and write MS Excel files using Java. Soon,
you'll be able to read and write Word files using Java. POI is your
Java Excel solution as well as your Java Word solution. However, we
have a complete API for porting other OLE 2 Compound Document formats
and welcome others to participate. OLE 2 Compound Document Format based
files include most Microsoft Office files such as XLS and DOC as well
as MFC serialization API based file formats.

Slide includes a fully featured WebDAV client library and command line
client.

This package contains releases for the 1.1.x versions of the Standard
Tag Library, Jakarta Taglibs's open source implementation of the JSP
Standard Tag Library (JSTL), version 1.1. JSTL is a standard under the
Java Community Process.

Jar Jar Links is a utility that makes it easy to repackage Java
libraries and embed them into your own distribution. This is useful for
two reasons: You can easily ship a single jar file with no external
dependencies. You can avoid problems where your library depends on a
specific version of a library, which may conflict with the dependencies
of another library.

JSP engine that conforms to the JSP 2.0 specifications from Java
Software.

This package contains shell scripts and symbolic links to simulate a
JPackage Java runtime environment with GCJ.