Download Jakarta SubProjects

Jakarta SubProjects
•Alexandria
•Ant
•Avalon
•BCEL
•BSF
•Cactus
•Commons
•ECS
•James
•Jetspeed
•JMeter
•Log4J
Lucene
•OJB
•ORO
•POI
•Regexp
•Slide
•Struts
•Taglibs
•Tomcat
•Turbine
•Velocity
•Watchdog
Jackliu 2002-11 [email protected]
The Alexandria Project
http://jakarta.apache.org/alexandria/index.html
Alexandria is a CVS/Javadoc/Source code/Documentation management system
meant for use within Open Source projects. It's goal is to create a global
documentation and source organization system to help people understand
source code and to share code across projects.
Alexandria is a Java centric project. The backend is implemented in all XML
which is driven by Ant, Xerces, and Xalan.
Definition of source code is done within XML and then transformed (XSLT)
into various HTML files and a master build.xml file which is used to drive Ant.
Ant attempts to download various CVS repositories and then builds Javadoc.
•Browse multiple and remote source repositories
•Generate Javadoc across multiple java projects
•Browse source code in an organized manner
•The "use" tag can be use across all projects within Alexandria
•Support multiple revisions of the same content
The Ant Project
http://jakarta.apache.org/ant/index.html
Apache Ant is a Java-based build tool. In theory, it is kind of like Make, but without Make's wrinkles.
Why another build tool when there is already make, gnumake, nmake, jam, and others? Because all
those tools have limitations that Ant's original author couldn't live with when developing software
across multiple platforms. Make-like tools are inherently shell-based -- they evaluate a set of
dependencies, then execute commands not unlike what you would issue in a shell. This means that
you can easily extend these tools by using or writing any program for the OS that you are working on.
However, this also means that you limit yourself to the OS, or at least the OS type such as Unix, that
you are working on.
Makefiles are inherently evil as well. Anybody who has worked on them for any time has run into the
dreaded tab problem. "Is my command not executing because I have a space in front of my tab!!!"
said the original author of Ant way too many times. Tools like Jam took care of this to a great degree,
but still have yet another format to use and remember.
Ant is different. Instead of a model where it is extended with shell-based commands, Ant is extended
using Java classes. Instead of writing shell commands, the configuration files are XML-based, calling
out a target tree where various tasks get executed. Each task is run by an object that implements a
particular Task interface.
Granted, this removes some of the expressive power that is inherent by being able to construct a shell
command such as `find . -name foo -exec rm {}`, but it gives you the ability to be cross platform -to work anywhere and everywhere. And hey, if you really need to execute a shell command, Ant has
an <exec> task that allows different commands to be executed based on the OS that it is executing on.
The Avalon Project
http://jakarta.apache.org/avalon/index.html
The Avalon project is an effort to create, design, develop and maintain a common framework
and set of components for applications written using the Java language.
Having said that, what Avalon 'is', is a framework that allows components of varying scale to
be created, managed via a specific set of lifecycle methods, and used in an application. While
Avalon is geared towards server-side applications, it is not limited to such, and is quite flexible.
The scope of usage for Avalon is quite broad. You may only want to create custom, application
specific components that can be managed in a well defined manner, or you may want to use
the many components and services available with the Excalibur sub-project, or use complete
applications, such as FTP or a web server, in a server oriented container such as Phoenix.
What this means to you is that you can use only what you need to use, and you can scale
your usage of Avalon as your application needs grow.
As many people point out, software engineering is a very uncommon procedure in software
development and even more uncommon in auto-organized open source projects. The main
goal of this project is to design a way for different projects to share resources avoiding as
much as possible efforts duplication.
The Avalon Team are proud to announce a new whitepaper that covers how to develop with
Avalon. It covers the Framework, and touches on the LogKit and Excalibur. You can find
Developing with Apache Avalon on this site.
The BCEL Project
http://jakarta.apache.org/bcel/index.html
The Byte Code Engineering Library (formerly known as
JavaClass) 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 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 is already being used successfully in several projects
such as compilers, optimizers, obsfuscators and analysis tools,
the most popular probably being the Xalan XSLT processor at
Apache.
The BSF(Bean Scripting Framework) Project
http://jakarta.apache.org/bsf/index.html
Bean Scripting Framework (BSF) is a set of Java classes which provides scripting
language support within Java applications, and access to Java objects and
methods from scripting languages. BSF allows one to write JSPs in languages
other than Java while providing access to the Java class library. In addition, BSF
permits any Java application to be implemented in part (or dynamically extended)
by a language that is embedded within it. This is achieved by providing an API
that permits calling scripting language engines from within Java, as well as an
object registry that exposes Java objects to these scripting language engines.
BSF supports several scripting languages currently:
•Javascript (using Rhino ECMAScript, from the Mozilla project)
•Python (using either Jython or JPython)
•Tcl (using Jacl)
•NetRexx (an extension of the IBM REXX scripting language in Java)
•XSLT Stylesheets (as a component of Apache XML project's Xalan and Xerces)
In addition, the following languages are supported with their own BSF engines:
•Java (using BeanShell, from the BeanShell project)
•JRuby
•JudoScript
Information on where to obtain scripting languages for use with BSF is available
on the Related Projects page.
The Cactus Project
http://jakarta.apache.org/cactus/index.html
Cactus is a simple test framework for unit testing server-side java code (Servlets, EJBs, Tag
Libs, Filters, ...).
The intent of Cactus is to lower the cost of writing tests for server-side code. It uses JUnit
and extends it.
Cactus has been developed with the idea of automatic testing in mind and it provides a
packaged and simple mechanism based on Ant to automate server-side testing.
Cactus implements an in-container strategy (click on the diagram below to understand how it
works). An alternative but complementary approach not covered by Cactus is to use Mock
Objects (see the Mock vs Container page to understand the differences and why Cactus
believes in the usefulness of an in-container approach).
The Commons Project
http://jakarta.apache.org/commons/index.html
The Commons Proper is dedicated to one principal goal: creating and
maintaining reusable Java components. The Commons Proper is a place for
collaboration and sharing, where developers from throughout the Jakarta
community can work together on projects to be shared by the Jakarta projects
and Jakarta users.
Commons developers will make an effort to ensure that their components have
minimal dependencies on other libraries, so that these components can be
deployed easily. In addition, Commons components will keep their interfaces as
stable as possible, so that Jakarta users (including other Jakarta subprojects)
can implement these components without having to worry about changes in the
future.
We welcome participation from all that are interested, at all skill levels. Coding,
documentation and testing are all critical parts of the software development
process. If you are interested in participating in any of these aspects, please join
us!
Components Repository:
BeanUtils Betwixt Cactus CLI Collections Discovery Digester DBCP
FileUpload HttpClient JXPath Lang Latka Logging Modeler Pool Validator
The ECS Project
http://jakarta.apache.org/ecs/index.html
The Element Construction Set is a
Java API for generating elements for
various markup languages it directly
supports HTML 4.0 and XML, but can
easily be extended to create tags for
any markup language. It is designed
and implemented by Stephan Nagy and
Jon S. Stevens.
The James Project
http://jakarta.apache.org/james/index.html
The Java Apache Mail Enterprise Server (a.k.a. Apache
James) is a 100% pure Java SMTP and POP3 Mail server,
and NNTP News server designed to be a complete and
portable enterprise mail engine solution based on
currently available open protocols.
James is also a mail application platform.
The James project hosts the Apache Mailet API, and
James provides and implementation of this mail
application platform API.
James is based upon the Apache Avalon application
framework. (For more information about Avalon, please
go to http://jakarta.apache.org/avalon)
James requires Java 2 (either JRE 1.3 or 1.4 as of
2.0a3).
The Jetspeed Project
http://jakarta.apache.org/jetspeed/site/index.html
Jetspeed is an Open Source implementation of an Enterprise Information Portal,
using Java and XML. A portal makes network resources (applications, databases
and so forth) available to end-users. The user can access the portal via a web
browser, WAP-phone, pager or any other device. Jetspeed acts as the central
hub where information from multiple sources are made available in an easy to
use manner.
The data presented via Jetspeed is independent of content type, This means that
content from for example XML,RSS or SMTP can be integrated with Jetspeed.
The actual presentation of the data is handled via ates XSL and delivered to the
user for example via the combination of Java Server Pages (JSPs) and HTML.
Jetspeed provides support for templating and content publication frameworks
such as Cocoon, WebMacro and Velocity. Note that outside of regualar browser
Jetspeed also supports WAP devices.
Jetspeed helps you build portal applications quickly. The goal is to make
Jetspeed a tool for both portal developers as well as user interface designers.
Currently the focus is on providing developers with a set of tools that facilitates
building the base for the portal. With Jetspeed you can quickly build an XML
portal and also syndicate your own content.
The JMeter Project
http://jakarta.apache.org/jmeter/index.html
Apache JMeter may be used to test performance both on static
and dynamic resources (files, Servlets, Perl scripts, Java
Objects, Data Bases and Queries, FTP Servers and more). It
can be used to simulate a heavy load on a server, network or
object to test its strength or to analyze overall performance
under different load types. You can use it to make a graphical
analysis of performance or to test your server/script/object
behavior under heavy concurrent load.
The Log4j Project
http://jakarta.apache.org/log4j/docs/index.html
Inserting log statements into your code is a low-tech method for debugging it. It may also be
the only way because debuggers are not always available or applicable. This is often the case
for distributed applications.
On the other hand, some people argue that log statements pollute source code and decrease
legibility. (We believe that the contrary is true). In the Java language where a preprocessor is
not available, log statements increase the size of the code and reduce its speed, even when
logging is turned off. Given that a reasonably sized application may contain thousands of log
statements, speed is of particular importance.
With log4j it is possible to enable logging at runtime without modifying the application binary.
The log4j package is designed so that these statements can remain in shipped code without
incurring a heavy performance cost. Logging behavior can be controlled by editing a
configuration file, without touching the application binary.
Logging equips the developer with detailed context for application failures. On the other hand,
testing provides quality assurance and confidence in the application. Logging and testing
should not be confused. They are complementary. When logging is wisely used, it can prove
to be an essential tool.
One of the distinctive features of log4j is the notion of inheritance in loggers. Using a logger
hierarchy it is possible to control which log statements are output at arbitrarily fine granularity
but also great ease. This helps reduce the volume of logged output and minimize the cost of
logging.
The target of the log output can be a file, an OutputStream, a java.io.Writer, a remote log4j
server, a remote Unix Syslog daemon, or even a NT Event logger among many other output
targets.
The Lucene Project
http://jakarta.apache.org/lucene/docs/index.html
Jakarta Lucene is a high-performance, full-featured text
search engine written entirely in Java. It is a technology
suitable for nearly any application that requires full-text
search, especially cross-platform.
Jakarta Lucene is an open source project available for
free download from Apache Jakarta. Please use the links
on the left to access Lucene.
The OJB Project
http://jakarta.apache.org/ojb/index.html
ObJectRelationalBridge (OJB) is an Object/Relational mapping tool that
allows transparent persistence for Java Objects against relational
databases.
OJB has been designed for a large range of applications, from
embedded systems to rich client application to multi-tier J2EE based
architectures.
•In standalone mode (or single VM mode) the OJB PersistenceBroker
is running in the same Java VM as the client application. This is useful
if only one instance of the client application is running (e.g. in
applications with a local database or in single-server Servlet- or EJB
applications). This is the default mode.
•In Client/Server mode. Multiple Clients can run against multiple
PersistenceBrokerServers running in multiple VMs on multiple physical
machines. This is useful in typical Client/Server scenarios or when an
ApplicationServer based application must be loadbalanced accross
multiple servers. See the Client/Server tutorial for details.
The ORO Project
http://jakarta.apache.org/oro/index.html
The Jakarta-ORO Java classes are a set of text-processing Java classes that
provide Perl5 compatible regular expressions, AWK-like regular expressions, glob
expressions, and utility classes for performing substitutions, splits, filtering
filenames, etc. This library is the successor to the OROMatcher, AwkTools,
PerlTools, and TextTools libraries from ORO, Inc. (www.oroinc.com). They have
been donated to the Jakarta Project by Daniel Savarese (www.savarese.org), the
copyright holder of the ORO libraries. Daniel will continue to participate in their
development under the Jakarta Project.
The Jakarta Project is lucky to also be able to offer another regexp solution for
you as well as this package. Options are a good thing and we will leave which
one you choose to use up to you. :-) They are both perfectly good packages, we
just consider the Jakarta ORO package to be more a more complete regular
expression package.
You can download the latest released version from the distribution directory.
The Javadoc is available online. It is also included in the distribution download.
If you would like to get involved with this project in one way or another (Mailing
lists, CVS, Contributions), please see the Getting Involved section of the Jakarta
Website.
The POI Project
http://jakarta.apache.org/poi/index.html
The POI project consists of APIs for manipulating various file formats
based upon Microsoft's OLE 2 Compound Document format using pure
Java.
OLE 2 Compound Document Format based files include most Microsoft
Office files such as XLS and DOC.
As a general policy we try to collaborate as much as possible with other
projects to provide this functionality. Examples include: Cocoon for
which you'll soon find generators and serializers for our projects; Open
Office.org with whom we collaborate in documenting the XLS format;
and Lucene for which we'll soon have file format interpretors. When
practical, we donate components directly to those projects for POIenabling them.
The Regexp Project
http://jakarta.apache.org/regexp/index.html
Regexp is a 100% Pure Java Regular Expression package that was graciously
donated to the Apache Software Foundation by Jonathan Locke. He originally
wrote this software back in 1996 and it has stood up quite well to the test of time.
It includes complete Javadoc documentation as well as a simple Applet for visual
debugging and testing suite for compatibility.
Contributors
•Jonathan Locke wrote the original code.
•James Davidson for making the contact with Jonathan and asking him to release his
source code.
•Jon S. Stevens is responsible for re-packaging it and preparing it for release.
•Craig McClanahan is responsible for setting up the CVS and mailing lists.
•Ales Novak has contributed bug fixes and feature enhancements.
•Michael McCallum contributed a patch to add clustering support.
The Slide Project
http://jakarta.apache.org/slide/index.html
The Slide project main module is a Content Management and Integration System,
which can be seen as a low-level content management framework. Conceptually,
it provides a hierarchical organization of binary content which can be stored into
arbitrary, heterogenous, distributed data stores. In addition, Slide integrates
security, locking, versioning, as well as many other services.
It can integrate and manage data stored within external repositories, requiring
only small abstraction layers to be written for each repository. That way, Slide
can integrate the data from various physical locations in a hierachical and unified
way. Slide uses can range from managing intranet application content (such as
the Exolab.org portal) to using it as a file server.
Slide also offers a WebDAV access module (implemented as a servlet). WebDAV
is an IETF standard endorsed by companies like Microsoft, IBM, Novell, Adobe
and many others. It makes Slide an ideal choice for web-based content
management. All the data managed by Slide can be accessed through WebDAV,
and enable remote administration and manipulation of the data managed by
Slide using standard third party tools, along with the custom ones provided in the
Slide distribution as additional tools.
The Taglibs Project
http://jakarta.apache.org/taglibs/index.html
This project is an open-source repository for JSP custom tag
libraries and associated projects, such as TagLibraryValidator
classes and extensions to page-creation tools to support tag
libraries. For a general description of Tag Libraries, please see
JSP(tm)
Tag
Libraries.
Jakarta Taglibs also hosts the development tree of the reference
implementation (RI) for the JSP Standard Tag Library (JSTL).
This implementation is done under project standard. Currently,
no other tag libraries in Jakarta Taglibs represent Java
Community Process (JCP) standards.
The Tomcat Project
http://jakarta.apache.org/tomcat/index.html
Tomcat is the servlet container that is used in the official
Reference Implementation for the Java Servlet and JavaServer
Pages technologies. The Java Servlet and JavaServer Pages
specifications are developed by Sun under the Java Community
Process.
Tomcat is developed in an open and participatory environment
and released under the Apache Software License. Tomcat is
intended to be a collaboration of the best-of-breed developers
from around the world. We invite you to participate in this open
development project. To learn more about getting involved, click
here.
The Turbine Project
http://jakarta.apache.org/turbine/index.html
Turbine is a servlet based framework that allows
experienced Java developers to quickly build secure web
applications. Parts of Turbine can also be used
independently of the web portion of Turbine as well. In
other words, we strive to make portions of Turbine
easily available for use in other applications.
Turbine is developed in an open and participatory
environment and released under the Apache Software
License . Turbine is intended to be a collaboration of the
best-of-breed developers from around the world. We
invite you to participate in this open development
project. To learn more about getting involved, click here .
The Velocity Project
http://jakarta.apache.org/velocity/index.html
Velocity is a Java-based template engine. It permits anyone to use the
simple yet powerful template language to reference objects defined in
Java code.
When Velocity is used for web development, Web designers can work
in parallel with Java programmers to develop web sites according to
the Model-View-Controller (MVC) model, meaning that web page
designers can focus solely on creating a site that looks good, and
programmers can focus solely on writing top-notch code. Velocity
separates Java code from the web pages, making the web site more
maintainable over the long run and providing a viable alternative to
Java Server Pages (JSPs) or PHP.
Velocity's capabilities reach well beyond the realm of web sites; for
example, it can generate SQL and PostScript and XML (see Anakia for
more information on XML transformations) from templates. It can be
used either as a standalone utility for generating source code and
reports, or as an integrated component of other systems. Velocity also
provides template services for the Turbine web application framework.
Velocity+Turbine provides a template service that allows web
applications to be developed according to a true MVC model.
The Watchdog Project
http://jakarta.apache.org/watchdog/index.html
Watchdog is a set of validation tests that can be run
against a Servlet 2.3 / JSP 1.2 container (such as
Tomcat 4.0 or Tomcat 4.1) to identify potential problems
with conformance to the corresponding specifications.
While it is not the official TCK for the Servlet or JSP
specifications, the tests it performs are similar.