I went ahead and committed a couple of tools which I have been using for
some time to ease the use of the ECM.
1)
The first is the ExcaliburComponentManagerCreator class. It is used to
manage the entire lifecycle of the ECM, RoleManager, LoggerManager and
optionally the InstrumentManager. And it can all be done with the
following code. Much simpler than having to everything manually each
time it is used:
Initialization:
---
m_componentManagerCreator = new ExcaliburComponentManagerCreator(
null, // Optional Context
new File( "../conf/logkit.xml" ),
new File( "../conf/roles.xml" ),
new File( "../conf/components.xml"),
new File( "../conf/instrument.xml" ) );
---
Accessing the ECM:
---
m_componentManager = m_componentManagerCreator.getComponentManager();
m_loggerManager = m_componentManagerCreator.getLoggerManager();
m_instrumentManager = m_componentManagerCreator.getInstrumentManager();
---
Shutdown:
---
m_componentManagerCreator.dispose();
m_componentManagerCreator = null;
---
It is as easy as that.
2)
The second utility class is the ExcaliburComponentManagerServlet. It is
located in the servlet subpackage and built into a seperate jar file:
excalibur-component-servlet-1.0.jar
The ECMServlet allows users who wish to use the ECM in a Servlet
environment to do so painlessly.
>From the javadocs: (Prettier in the javadocs)
---
Makes it possible for servlets to work with Avalon components without
having to do any coding to setup and manage the lifecycle of the
ComponentManager. To make use of the ExcaliburComponentManagerServet.
You will need to define the servlet in your web.xml file as follows:
<!-- ExcaliburComponentManagerServlet (for initializing
ComponentManager). -->
<servlet>
<servlet-name>ExcaliburComponentManagerServlet</servlet-name>
<display-name>ExcaliburComponentManagerServlet</display-name>
<description>Creates component manager, does not service
requests.</description>
<servlet-class>
org.apache.avalon.excalibur.component.servlet.ExcaliburComponentManagerServlet
</servlet-class>
<!-- This parameter points to the logkit configuration file. -->
<!-- Note that the path is specified in absolute notation but it will be -->
<!-- resolved relative to the servlets webapp context path -->
<init-param>
<param-name>logkit</param-name>
<param-value>/WEB-INF/logkit.xml</param-value>
</init-param>
<!-- This parameter points to the components configuration file. -->
<init-param>
<param-name>components</param-name>
<param-value>/WEB-INF/components.xml</param-value>
</init-param>
<!-- Roles file supplements configuration file to make the latter -->
<!-- more readable. Most likely you don't want to change the roles -->
<!-- file -->
<init-param>
<param-name>roles</param-name>
<param-value>/WEB-INF/roles.xml</param-value>
</init-param>
<!-- This parameter points to the instrument manager configuration file. -->
<init-param>
<param-name>instrument</param-name>
<param-value>/WEB-INF/instrument.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
Please pay particular attention to the load-on-startup element. It is
used to control the order in which servlets are started by the servlet
engine. It must have a value which is less than any other servlets
making use of the ComponentManager. This is to ensure that the
ComponentManager is initialized before any other servlets attempt to
start using it.
All of the configuration files are located in the WEB-INF directory by
default. The instrument configuration file is optional. Please see the
ExcaliburComponentManagerCreator class for details on
what goes into these configuration files. Note that the lifecycle of the
ExcaliburComponentManagerCreator is managed automatically by this
servlet, so there is no need to access the class directly.
Once the servlet has been configured, other servlets may gain access to
the ComponentManager, InstrumentManager and LoggerManager via the
ServletContext using the following code within a servlet:
// Get a reference to the ServletContext
ServletContext servletContext = getServletContext();
// Acquire the LoggerManager
LoggerManager loggerManager =
(LoggerManager)m_servletContext.getAttribute(
LoggerManager.class.getName() );
// Acquire the InstrumentManager
InstrumentManager instrumentManager =
(InstrumentManager)m_servletContext.getAttribute(
InstrumentManager.class.getName() );
// Acquire the ComponentManager
ComponentManager componentManager =
(ComponentManager)m_servletContext.getAttribute(
ComponentManager.class.getName() );
The ExcaliburComponentManagerServlet makes use of a proxy system to
manage reference to the above managers, so it is not necessary to
release them when a servlet is done using them.
---
Cheers,
Leif
--
To unsubscribe, e-mail: <mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>
