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 jackliu@cn-java.com

The Alexandria Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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) Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 POI-enabling them.

The Regexp Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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 Projecthttp://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.