leosutic 2002/06/29 07:47:48
Modified: microcontainer/src/xdocs index.xml
microcontainer/src/xdocs/stylesheets project.xml
Added: microcontainer/src/xdocs tutorial.xml ShowDatabases.java
Log:
Initial check-in of the "Extremely Quick and Easy" tutorial.
Revision Changes Path
1.3 +107 -22
jakarta-avalon-excalibur/microcontainer/src/xdocs/index.xml
Index: index.xml
===================================================================
RCS file:
/home/cvs/jakarta-avalon-excalibur/microcontainer/src/xdocs/index.xml,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- index.xml 27 Jun 2002 14:34:05 -0000 1.2
+++ index.xml 29 Jun 2002 14:47:48 -0000 1.3
@@ -1,30 +1,115 @@
<?xml version="1.0"?>
<document>
<properties>
- <title>Excalibur I/O Extensions - Overview</title>
- <author email="[email protected]">Avalon Documentation
Team</author>
+ <title>Overview</title>
+ <author email="mailto:[EMAIL PROTECTED]">Leo Sutic</author>
</properties>
<body>
- <section name="Introduction">
- <p>Avalon Excalibur's Input/Output utilities are in package
- <code>org.apache.avalon.excalibur.io</code>.</p>
-
- <subsection name="Copy methods">
- <p>Excalibur's IO package contains a comprehensive set of
routines for
- copying bytes and chars. Routines exist for copying from:
- <code>String</code>, <code>byte[]</code>,
<code>Reader</code> and
- <code>InputStream</code>, to:<code>String</code>,
<code>byte[]</code>,
- <code>Writer</code> and <code>OutputStream</code>.
- </p>
- </subsection>
-
- <subsection name="Useful java.io.FileFilters">
- <p>
- Excalibur includes a number of FileFilters that you can
use for your
- own purposes. This fills a gap in the Java runtime because
the
- interface was specified but no implementations were given.
- </p>
- </subsection>
+ <section name="What is MicroContainer?">
+ <p>
+ MicroContainer's purpose is to provide a way to use Avalon
+ components without having to commit to the Avalon
architecture.
+ </p>
+
+ <p>
+ It does so by:
+ </p>
+
+ <ul>
+ <li>
+ <p>
+ <b>Using standard Java idioms whenever possible.</b>
Use of Avalon components
+ should be as similar as possible to the use of
standard Java classes.
+ </p>
+ </li>
+ <li>
+ <p>
+ <b>Removing the need for XML assembly and/or
deployment descriptors.</b> Having
+ those means that you are forced to include XML
parsing ability and need to
+ integrate the configuration with your own existing
architecture.
+ </p>
+ </li>
+ <li>
+ <p>
+ <b>Removing the need to center the application
around the component container.</b>
+ Most Avalon applications are centered around a
component container, such as Fortress,
+ Phoenix or the Excalibur Component Manager (Cocoon).
By removing that need, it
+ is easier to just pick an Avalon component and have
it work with your existing
+ architecture. <i>A MicroContainer will fit
anywhere.</i>
+ </p>
+ </li>
+ </ul>
+ </section>
+
+ <section name="Getting Started">
+ <p>
+ Does the above sound like something you'd like to use? Great!
+ </p>
+
+ <ul>
+ <li>
+ <p>
+ You can download
+ the latest development JAR from <a
href="http://gump.covalent.net/jars/latest/jakarta-avalon-excalibur/";>
+
http://gump.covalent.net/jars/latest/jakarta-avalon-excalibur/</a>. Scroll down
and you'll see a
+ file named
<code>excalibur-microcontainer-YYYYMMDD.jar</code>, with YYYYMMDD being the
date the
+ jar was built.
+ </p>
+ </li>
+ <li>
+ <p>
+ If you do not have it already, you should grab a
copy of <a
href="http://gump.covalent.net/jars/latest/jakarta-avalon/avalon-framework.jar";>avalon-framework.jar</a>.
+ </p>
+ </li>
+ <li>
+ <p>
+ If you want to try the DataSource sample of the <a
href="tutorial.html">tutorial</a>, you should go to:
+ <a
href="http://gump.covalent.net/jars/latest/jakarta-avalon-excalibur/";>
+
http://gump.covalent.net/jars/latest/jakarta-avalon-excalibur/</a> and download
+ <code>excalibur-datasource-YYYYMMDD.jar</code>,
<code>excalibur-pool-YYYYMMDD.jar</code> and
<code>excalibur-collections-YYYYMMDD.jar</code>.
+ As with the MicroContainer JAR, the YYYYMMDD will be
the date the JAR was built.
+ </p>
+ </li>
+ </ul>
+ </section>
+
+ <section name="Project Status">
+ <p>
+ MicroContainer has not yet had an official release. What
this means for you is:
+ </p>
+
+ <ul>
+ <li>
+ <p>
+ <b>The API may change.</b> While every effort will
be made to keep API changes to
+ a minimum and to always provide backwards binary
compatibility, some times
+ a developer must admit that he was going about it
the wrong way and needs
+ to restructure parts of the project.
+ </p>
+ </li>
+ <li>
+ <p>
+ <b>The documentation isn't quite complete.</b>
+ </p>
+ </li>
+ <li>
+ <p>
+ <b>You should hide your use of MicroContainer behind
factory methods.</b>
+ See the <a href="tutorial.html">tutorial</a> for an
example of how to do
+ this. If you do so, API changes will impact you
minimally should they
+ happen.
+ </p>
+ </li>
+ </ul>
+ </section>
+
+ <section name="Needing Help?">
+ <p>
+ So it stubbornly refuses to work, does it? Defiantly
throwing Exceptions all over
+ your code? MicroContainer, and all other Avalon projects are
discussed in the
+ <a href="http://jakarta.apache.org/site/mail.html";>The
Avalon User List</a>.
+ Subscribe to it and post your question there.
+ </p>
</section>
</body>
</document>
1.1
jakarta-avalon-excalibur/microcontainer/src/xdocs/tutorial.xml
Index: tutorial.xml
===================================================================
<?xml version="1.0"?>
<document>
<properties>
<title>Extremely Quick and Easy Tutorial</title>
<author email="mailto:[EMAIL PROTECTED]">Leo Sutic</author>
</properties>
<body>
<section name="Extremely Quick and Easy Tutorial">
<p>
Welcome to the <b>Extremely Quick and Easy Tutorial</b>. This
is what it
consists of:
</p>
<ul>
<li>
<p>
First, we'll make sure you have all the required JAR
files.
</p>
</li>
<li>
<p>
Second, we'll set up your CLASSPATH correctly.
</p>
</li>
<li>
<p>
After that, a short discussion of what makes an
Avalon component
different from a regular Java class, and what
MicroContainer does.
</p>
</li>
<li>
<p>
Fourth, an example that uses the Excalibur DataSource
to list all
databases in a MySQL installation.
</p>
</li>
<li>
<p>
And finally, we'll take a look at the factory that
produces a
MicroContainer for the DataSource.
</p>
</li>
</ul>
</section>
<section name="Getting the JAR Files">
<p>
You need the following JAR files:
</p>
<ul>
<li>
<p>
<b>excalibur-microcontainer</b>: You can download
the latest development JAR from <a
href="http://gump.covalent.net/jars/latest/jakarta-avalon-excalibur/";>
http://gump.covalent.net/jars/latest/jakarta-avalon-excalibur/</a>. Scroll down
and you'll see a
file named
<code>excalibur-microcontainer-YYYYMMDD.jar</code>, with YYYYMMDD being the
date the
jar was built.
</p>
</li>
<li>
<p>
<b>avalon-framework</b>: If you do not have it
already, you should grab a copy of
<a
href="http://gump.covalent.net/jars/latest/jakarta-avalon/avalon-framework.jar";>avalon-framework.jar</a>.
</p>
</li>
<li>
<p>
<b>excailbur-datasource</b>: Go to:
<a
href="http://gump.covalent.net/jars/latest/jakarta-avalon-excalibur/";>
http://gump.covalent.net/jars/latest/jakarta-avalon-excalibur/</a> and
download</p>
<ul>
<li>
<p>
<code>excalibur-datasource-YYYYMMDD.jar</code>
</p>
</li>
<li>
<p>
<code>excalibur-pool-YYYYMMDD.jar</code>
</p>
</li>
<li>
<p>
<code>excalibur-collections-YYYYMMDD.jar</code>
</p>
</li>
</ul>
<p>
As with the MicroContainer JAR, the YYYYMMDD will be
the date the JAR was built.
</p>
</li>
<li>
<p>
You also need a JAR with drivers for your database.
If you, like me, use
MySQL, you can find drivers at <a
href="http://mmmysql.sourceforge.net/";>http://mmmysql.sourceforge.net/</a>.
</p>
<ul>
<li>
<p>
Click on the <b>download</b> link and select
<code>mm.mysql-2.0.9-you-must-unjar-me.jar</code>.
Note the version number - the other downloads
are source distributions.
</p>
</li>
<li>
<p>
Unjar the file you just downloaded and find
the file <code>mm.mysql-2.0.9-bin.jar</code>. This is
the file containing DB drivers for MySQL.
</p>
</li>
</ul>
</li>
</ul>
</section>
<section name="Setting up your CLASSPATH">
<p>
Now that you have all JAR files, create a directory for the
tutorial and copy the files into it.
</p>
<source><![CDATA[
C:\microcontainertutorial>dir
Volume in drive C has no label.
Volume Serial Number is 6C66-7072
Directory of C:\microcontainertutorial
2002-06-29 16:26 <DIR> .
2002-06-29 16:26 <DIR> ..
2002-06-29 16:26 59 369 avalon-framework.jar
2002-06-29 16:26 33 563 excalibur-collections-20020628.jar
2002-06-29 16:26 42 775 excalibur-datasource-20020628.jar
2002-06-29 16:25 29 623 excalibur-microcontainer-20020628.jar
2002-06-29 16:26 44 453 excalibur-pool-20020628.jar
2002-01-19 10:55 121 015 mm.mysql-2.0.9-bin.jar
7 File(s) 330 798 bytes
2 Dir(s) 11 774 013 440 bytes free
C:\microcontainertutorial>]]></source>
<p>You need to include all the above jars in your classpath.</p>
<source><![CDATA[
SET CLASSPATH=avalon-framework.jar;excalibur-collections-20020628.jar
SET CLASSPATH=%CLASSPATH%;excalibur-datasource-20020628.jar
SET CLASSPATH=%CLASSPATH%;excalibur-microcontainer-20020628.jar
SET CLASSPATH=%CLASSPATH%;excalibur-pool-20020628.jar;mm.mysql-2.0.9-bin.jar
SET CLASSPATH=%CLASSPATH%;.
]]></source>
<p>
Note that the last SET command includes the current directory
in the classpath.
</p>
</section>
<section name="What Makes an Avalon Component so Special?">
<p>
In five words: <b>It expects to be managed.</b>
</p>
<p>
When you use a regular Java class, you would typically call
its constructor
and then start using it. Basically, as soon as you have an
instance of the class,
it is good to go.
</p>
<p>
Avalon components are different. For example, if the
component class implements
the
<code>org.apache.avalon.framework.activity.Initializable</code> interface,
it will have an <code>initialize()</code> method that
<b>must</b> be
called before the component is ready to be used.
Another difference is that all components have a no-argument
constructor. Those
components that have configuration parameters will implement
the
<code>org.apache.avalon.framework.configuration.Configurable</code>
interface, which defines a single method: <code>configure(
Configuration config );</code>.
The component then expects to recieve all configuration
parameters via that
method.
</p>
<p>
This is why a <b>container</b> is needed. The container is
responsible for
calling the right methods with the correct parameters, and in
general manage the component
the way it expects to be managed.
</p>
<p>
MicroContainer's goal is to provide such a container that can
easily be used in
any kind of program, and to have minimal impact on your
existing code. In particular,
MicroContainer is special because <b>it only manages a single
component</b>. All the
other containers manage several components. MicroContainer
manages one. The other
containers solve the use case where one component uses
another by linking them
up inside the container - MicroContainer allows you to link
several MicroContainers
together for the same purpose.
</p>
</section>
<section name="Accessing a MySQL Database with MicroContainer">
<p>
Now that we have a good idea of what makes Avalon components
special,
let's get down to practicalities. In particular, how would
one use MicroContainer
in combination with the Excalibur DataSource to access a
MySQL database?
</p>
<p>
You can download the sample <a
href="ShowDatabases.java">here</a>.
Starting with the <code>import</code> declarations, here's
the sample code:
</p>
<source><![CDATA[import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.StringTokenizer;
import org.apache.avalon.excalibur.datasource.DataSourceComponent;
import org.apache.avalon.excalibur.datasource.JdbcDataSource;
import org.apache.excalibur.microcontainer.MicroContainer;
import org.apache.excalibur.microcontainer.util.DataSourceFactory;
/**
* Sample code to show all databases in a MySQL installation.
*/
public class ShowDatabases
{]]></source>
<p>
For now, we will use the
<code>org.apache.excalibur.microcontainer.util.DataSourceFactory</code>
to create a MicroContainer for a
<code>org.apache.avalon.excalibur.datasource.JdbcDataSource</code>.
This is just to quickly get something that can run. As soon
as this version runs, we will dig
into the <code>DataSourceFactory</code> class and see how to
create a MicroContainer.
</p>
<p>
Proceeding with the sample code, here's the top of the
<code>main</code> method:
</p>
<source><![CDATA[
/**
* Main method.
*/
public static void main( String[] args ) throws Exception
{
String driver = "org.gjt.mm.mysql.Driver";
String dbUrl = "jdbc:mysql://localhost/";
String query = "SHOW DATABASES;";
String userName = "sa";
String password = "";
System.out.println( "Attempting to create a DataSourceComponent with
the following parameters:" );
System.out.println( " Driver: " + driver );
System.out.println( " DB URL: " + dbUrl );
System.out.println( "User name: " + userName );
System.out.println( " Password: " + (password != null ? "(hidden)" :
"(not specified)") );]]></source>
<p>
Some fairly basic initialization followed by a status
message. You should edit the
parameters to fit your MySQL configuration.
</p>
<p>
Now we come to the creation of a DataSourceComponent.
</p>
<source><![CDATA[
DataSourceComponent ds = DataSourceFactory.getDataSource(
driver, // JDBC Driver
dbUrl, // Database URL
userName, // user name
password, // user's password
null, // Connection keep-alive command (none)
1, // Minimum number of connections in pool.
3, // Maximum number of connections in pool.
-1, // Connection timeout (disabled)
true, // Auto commit
false, // Using oracle (only relevant when supplying
a keep-alive command)
null); // Override name of connection class (null ==
use default).]]></source>
<p>
A bit of pure magic hidden inside
<code>DataSourceFactory.getDataSource()</code> for now.
The method takes creation parameters for the DataSource, and
returns a MicroContainer that
implements the <code>DataSourceComponent</code>. This is
important to remember: <b>The
object returned by the <code>getDataSource</code> method
is a MicroContainer, and not
an instance of the Avalon component.</b> Via dynamic
proxies, the MicroContainer will
implement all interfaces that the component does, thus
enabling it to be used just
as a component, but keep in mind that it is a proxy.
</p>
<p>
Finally, the code to get a connection, execute a query, and
close everything down.
</p>
<source><![CDATA[
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try
{
conn = ds.getConnection();
stmt = conn.createStatement();
System.out.println( "\nExecuting query: " + query + "\n" );
rs = stmt.executeQuery( query );
System.out.println( "The following databases were found:" );
while (rs.next())
{
System.out.println( rs.getObject( 1 ) );
}
}
finally
{
if( rs != null )
{
rs.close();
}
if( stmt != null )
{
stmt.close();
}
if( conn != null )
{
conn.close();
}
MicroContainer.release(ds);
}
}
}]]></source>
<p>
The above is some fairly straight JDBC access. Do, however,
note the <code>MicroContainer.release(ds);</code>
at the bottom. As I said above, Avalon components expect to
be managed during their initialization phase.
They also expect to be managed when shutting down. That's why
all MicroContainers must be explicitly released.
</p>
<p>
At this point, you should compile and test the code with
</p>
<source>javac *.java</source>
<p>
and
</p>
<source>java ShowDatabases</source>
<p>
If it works, it should result in output similar to this:
</p>
<source><![CDATA[Attempting to create a DataSourceComponent with
the following parameters:
Driver: org.gjt.mm.mysql.Driver
DB URL: jdbc:mysql://localhost/
User name: sa
Password: (hidden)
Executing query: SHOW DATABASES;
The following databases were found:
mysql
sample
test
]]> </source>
</section>
<section name="The DataSourceFactory.getDataSource() Method">
<p>
The problem of creating a suitable MicroContainer for a
DataSource boils down to this:
Since the JdbcDataSource class (which we will use) implements
<code>Configurable</code>,
it expects configuration parameters in the form of a
<code>Configuration</code> object,
and we must create a suitable such object for it. All other
aspects of management
can be handled by the MicroContainer.
</p>
<p>
Looking at the Javadoc for
<code>org.apache.avalon.excalibur.datasource.JdbcDataSource</code>
we see that the components expects a configuration like this:
</p>
<source><![CDATA[
<configuration>
<pool-controller min="5" max="10"
connection-class="my.overrided.ConnectionClass">
<keep-alive disable="false">select 1</keep-alive>
</pool-controller>
<auto-commit>true</auto-commit>
<driver>com.database.jdbc.JdbcDriver</driver>
<dburl>jdbc:driver://host/mydb</dburl>
<user>username</user>
<password>password</password>
</configuration>
]]></source>
<p>
One thing that is apparent from the configuration above is
that it uses the value
part of the configurations to pass parameters and not the
attributes. That is, instead of
having <code><user name="username"/></code>, it has
<code><user>username</user></code>.
So we'll create utility method to create such configuration
elements first.
</p>
<source><![CDATA[
import org.apache.avalon.excalibur.datasource.DataSourceComponent;
import org.apache.avalon.excalibur.datasource.JdbcDataSource;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.excalibur.microcontainer.MicroContainer;
import org.apache.excalibur.microcontainer.MicroContainerException;
public class DataSourceFactory
{
private static final DefaultConfiguration configurationWithValue( String
name, String value )
{
DefaultConfiguration child = new DefaultConfiguration( name, "" );
child.setValue( value );
return child;
}
]]></source>
<p>
The method will create a <code>DefaultConfiguration</code>,
sets its value and return it.
For example, to create
<code><user>username</user></code>, we would call it
thus:
</p>
<source><![CDATA[
configurationWithValue( "user", "username" )
]]> </source>
<p>
Right then, here's the parts that creates the configuration
object:
</p>
<source><![CDATA[
public static DataSourceComponent getDataSource(
String driver, String dbUrl, String user,
String password, String keepAliveCommand,
int poolMin, int poolMax, long timeout,
boolean autoCommit, boolean useOracle,
String connectionClass ) throws MicroContainerException
{
DefaultConfiguration config = new DefaultConfiguration( "", "" );
config.addChild( configurationWithValue( "driver", driver ) );
config.addChild( configurationWithValue( "dburl", dbUrl ) );
config.addChild( configurationWithValue( "user", user ) );
config.addChild( configurationWithValue( "password", password ) );
config.addChild( configurationWithValue( "auto-commit", String.valueOf(
autoCommit ) ) );
DefaultConfiguration controller = new DefaultConfiguration(
"pool-controller", "" );
controller.setAttribute( "min", String.valueOf( poolMin ) );
controller.setAttribute( "max", String.valueOf( poolMax ) );
controller.setAttribute( "timeout", String.valueOf( timeout ) );
controller.setAttribute( "oradb", String.valueOf( useOracle ) );
if( connectionClass != null )
{
controller.setAttribute( "connection-class", connectionClass );
}
DefaultConfiguration keepAlive = new DefaultConfiguration( "keep-alive",
"" );
if( keepAliveCommand != null )
{
keepAlive.setValue( keepAliveCommand );
}
else
{
keepAlive.setAttribute( "disable", "true" );
}
controller.addChild( keepAlive );
config.addChild( controller );
]]> </source>
<p>
You are probably recoiling in shock and horror at the above.
After all,
MicroContainer was supposed to reduce complexity, wasn't it?
Well, creating a configuration instance programmatically is
dirty. There's
just not many other ways to do it. Second, the
<code>JdbcDataSource</code>
class has a fairly massive configuration with lots of
parameters.
</p>
<p>
(If there were any other component with simpler configuration
and that
yet was as easy to write a sample program for, I would have
used it here instead.)
</p>
<p>
The DataSource component we wanted to use required a
configuration. We have one now,
and can thus go on to create the actual MicroContainer:
</p>
<source><![CDATA[
return (DataSourceComponent) new MicroContainer( JdbcDataSource.class
).configuration( config ).create();
]]> </source>
<p>
And that was it. Note that the <code>MicroContainer</code>
class follows the named parameter
idiom.
</p>
</section>
<section name="Needing Help?">
<p>
So it stubbornly refuses to work, does it? Defiantly throwing
Exceptions all over
your code? MicroContainer, and all other Avalon projects are
discussed in the
<a href="http://jakarta.apache.org/site/mail.html";>The Avalon
User List</a>.
Subscribe to it and post your question there.
</p>
</section>
</body>
</document>
1.1
jakarta-avalon-excalibur/microcontainer/src/xdocs/ShowDatabases.java
Index: ShowDatabases.java
===================================================================
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.StringTokenizer;
import org.apache.avalon.excalibur.datasource.DataSourceComponent;
import org.apache.avalon.excalibur.datasource.JdbcDataSource;
import org.apache.excalibur.microcontainer.MicroContainer;
import org.apache.excalibur.microcontainer.util.DataSourceFactory;
/**
* Sample code to show all databases in a MySQL installation.
*
* @author <a href="mailto:[EMAIL PROTECTED]">Leo Sutic</a>
*/
public class ShowDatabases
{
/**
* Main method.
*/
public static void main( String[] args ) throws Exception
{
String driver = "org.gjt.mm.mysql.Driver";
String dbUrl = "jdbc:mysql://localhost/";
String query = "SHOW DATABASES;";
String userName = "sa";
String password = "";
System.out.println( "Attempting to create a DataSourceComponent with
the following parameters:" );
System.out.println( " Driver: " + driver );
System.out.println( " DB URL: " + dbUrl );
System.out.println( "User name: " + userName );
System.out.println( " Password: " + (password != null ? "(hidden)" :
"(not specified)") );
DataSourceComponent ds = DataSourceFactory.getDataSource(
driver, // JDBC Driver
dbUrl, // Database URL
userName, // user name
password, // user's password
null, // Connection keep-alive command (none)
1, // Minimum number of connections in pool.
3, // Maximum number of connections in pool.
-1, // Connection timeout (disabled)
true, // Auto commit
false, // Using oracle (only relevant when supplying a
keep-alive command)
null); // Override name of connection class (null == use
default).
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try
{
conn = ds.getConnection();
stmt = conn.createStatement();
System.out.println( "\nExecuting query: " + query + "\n" );
rs = stmt.executeQuery( query );
System.out.println( "The following databases were found:" );
while (rs.next())
{
System.out.println( rs.getObject( 1 ) );
}
}
finally
{
if( rs != null )
{
rs.close();
}
if( stmt != null )
{
stmt.close();
}
if( conn != null )
{
conn.close();
}
MicroContainer.release(ds);
}
}
}
1.2 +18 -13
jakarta-avalon-excalibur/microcontainer/src/xdocs/stylesheets/project.xml
Index: project.xml
===================================================================
RCS file:
/home/cvs/jakarta-avalon-excalibur/microcontainer/src/xdocs/stylesheets/project.xml,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- project.xml 27 Jun 2002 14:35:32 -0000 1.1
+++ project.xml 29 Jun 2002 14:47:48 -0000 1.2
@@ -1,16 +1,21 @@
<?xml version="1.0" encoding="UTF-8"?>
<project name="Excalibur MicroContainer"
href="http://jakarta.apache.org/avalon/excalibur/microcontainer";>
-
- <title>Excalibur MicroContainer</title>
- <body>
- <item href="@AVALON_BASE@" name="Back to Avalon"/>
- <item href="/../index.html" name="Back to Excalibur"/>
-
- <menu name="About">
- <item name="Overview" href="/index.html"/>
- <item name="Excalibur Home"
href="http://jakarta.apache.org/avalon/excalibur/index.html"/>
- <item name="Download"
href="http://jakarta.apache.org/builds/jakarta-avalon-excalibur/release/microcontainer"/>
- <item name="API Docs" href="/api/index.html"/>
- </menu>
- </body>
+
+ <title>Excalibur MicroContainer</title>
+ <body>
+ <item href="@AVALON_BASE@" name="Back to Avalon"/>
+ <item href="/../index.html" name="Back to Excalibur"/>
+
+ <menu name="About">
+ <item name="Overview" href="/index.html"/>
+ <item name="Excalibur Home"
href="http://jakarta.apache.org/avalon/excalibur/index.html"/>
+ <item name="Download"
href="http://jakarta.apache.org/builds/jakarta-avalon-excalibur/release/microcontainer"/>
+ <item name="API Docs" href="/api/index.html"/>
+ <item name="Extremely Quick and Easy Tutorial"
href="/tutorial.html"/>
+ </menu>
+
+ <menu name="Developers">
+ <item name="Things to Keep in Mind" href="/keepinmind.html"/>
+ </menu>
+ </body>
</project>
--
To unsubscribe, e-mail: <mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>
