"An author doesn't necessarily understand the meaning of his own story better than anyone else."
Before you can build an application, you need to lay a solid foundation. There are several setup tasks you need to perform before deploying your application. These include components in the configuration file and in the Web Application Deployment Descriptor.
The
Writing Action
Mappings
section covered writing the
<form-bean>
and
<action-mapping>
portions of the configuration file.
These elements usually play an important role in the
development of an
application.
The other elements in a configuration file tend to be
static:
you set them once and leave them alone.
These "static" configuration elements are:
The
<controller>
element allows you to configure
the ActionServlet.
Many of the controller parameters were previously defined
by servlet
initialization parameters in your
web.xml
file but have been
moved to this section of
struts-config.xml
in order to allow
different modules in the same web application to be
configured differently.
For full details on available parameters see the
struts-config DTDDoc
or the list below.
<forward>
element is mapped to a
context-relative URL when it starts with a slash.
This value may consist of any combination of the
following:
<forward>
element.
true
if you want the
input
attribute of
<action>
elements
to be the name of a local or global
ActionForward
, which
will then be used to calculate the ultimate URL.
Set to
false
to treat the
input
parameter of
<action>
elements as a module-relative path to
the resource to be used as the input form.
[false] (optional)
true
if you want a
Locale
object stored in the user's session if not already
present.
[true] (optional)
true
if you want the controller
to add HTTP headers for defeating caching to every
response from
this module.
[false] (optional)
page
attribute of custom tags using it is mapped to a
context-relative URL of the corresponding resource.
This value may consist of any combination of the
following:
<forward>
element.
RequestProcessor
subclass to be used with this module.
[org.apache.struts.chain.ComposableRequestProcessor]
(optional)
This example uses the default values for several controller parameters. If you only want default behavior you can omit the controller section altogether.
<controller
processorClass="org.apache.struts.action.RequestProcessor"
contentType="text/html"/>;
The framework has built in support for
internationalization (I18N).
You can define one or more
<message-resources>
elements
for your webapp; modules can define their own resource
bundles.
Different bundles can be used simultaneously in your
application, the 'key'
attribute is used to specify the desired bundle.
false
to display missing resource
keys in your application like '
???keyname???
' instead of
null
.
[true] (optional)
true
if
escape processing
should be performed on the error message string.
[true] (optional)
Example configuration:
<message-resources
parameter="MyWebAppResources"
null="false" />
This would set up a message resource bundle provided in
the file
MyWebAppResources.properties
under the default key.
Missing resource keys would be displayed as '
???keyname???
'.
The default PropertyMessageResources
implementation can operate in one of three modes:
PropertyResourceBundle finds messages.
The mode can be configured in the struts-config.xml
(for more details see PropertyMessageResources
JavaDoc):.
<message-resources parameter="MyWebAppResources">
<set-property key="mode" value="JSTL"/>
</message-resources>
Struts PlugIns are configured using the
<plug-in>
element within the configuration file.
This element has only one valid attribute, 'className',
which is the fully
qualified name of the Java class which implements the
org.apache.struts.action.PlugIn
interface.
For PlugIns that require configuration themselves, the
nested
<set-property>
element is available.
This is an example using the Tiles plugin:
<plug-in className="org.apache.struts.tiles.TilesPlugin">
<set-property
property="definitions-config"
value="/WEB-INF/tiles-defs.xml"/>
</plug-in>
Very little is required in order to start taking advantage of the module feature. Just go through the following steps:
Back in version 1.0, a few "boot-strap" options were placed
in the
web.xml
file, and the bulk of the configuration was done in a
single
struts-config.xml
file.
Obviously, this wasn't ideal for a team environment, since
multiple users
had to share the same configuration file.
Since version 1.1, you have two options: you can list multiple struts-config files as a comma-delimited list, or you can subdivide a larger application into modules.
With the advent of modules, a given module has its own configuration file. This means each team (each module would presumably be developed by a single team) has their own configuration file, and there should be a lot less contention when trying to modify it.
Since version 1.0, you listed your configuration file as an
initialization
parameter to the action servlet in
web.xml.
This is still done since version 1.1, but the parameter can
be extended.
In order to tell the framework machinery about your
different modules, you
specify multiple 'config' initialization parameters, with
a slight twist.
You'll still use 'config' to tell the ActionServlet about
your "default"
module, however, for each additional module, you will
list an initialization parameter named "config
/module
", where
/module
is
the prefix for your module (this gets used when
determining which URIs fall
under a given module, so choose something meaningful!).
For example:
...
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/conf/struts-default.xml</param-value>
</init-param>
<init-param>
<param-name>config/module1</param-name>
<param-value>/WEB-INF/conf/struts-module1.xml</param-value>
</init-param>
...
Here we have two modules.
One happens to be the "default" module, identified by the
param-name of
"config", and the other will be using the module prefix
"/module1" based
on the param-name it was given ("config/module1").
The controller is configured to find the respective
configuration files
under
/WEB-INF/conf/
(which is the recommended place to put all configuration
files).
Pretty simple!
(The
struts-default.xml
would be equivalent to what most folks call
struts-config.xml.
I just like the symmetry of having all my module
configuration files being
named
struts-
module.xml
)
If you'd like to vary where the pages for each module are stored, see the forwardPattern setting for the Controller.
There are three approaches for switching from one module to another.
org.apache.struts.actions.SwitchAction
from the Extras JAR,
<forward>
(global or local) and specify the contextRelative
attribute with a value of true,
You can use
org.apache.struts.actions.SwitchAction
like so:
...
<action-mappings>
<action path="/toModule"
type="org.apache.struts.actions.SwitchAction"/>
...
</action-mappings>
...
Now, to change to ModuleB, we would use a URI like this:
http://localhost:8080/toModule.do?prefix=/moduleB&page=/index.do
If you are using the "default" module as well as "named" modules (like "/moduleB"), you can switch back to the "default" module with a URI like this:
http://localhost:8080/toModule.do?prefix=&page=/index.do
Here's an example of a global forward:
<global-forwards>
<forward name="toModuleB"
contextRelative="true"
path="/moduleB/index.do"
redirect="true"/>
...
</global-forwards>
You could do the same thing with a local forward declared in an ActionMapping:
<action-mappings>
<action ... >
<forward name="success"
contextRelative="true"
path="/moduleB/index.do"
redirect="true"/>
</action>
...
</action-mappings>
Using the module parameter with a hyperlink tag is even simpler:
<html:link module="/moduleB" path="/index.do"/>
That's all there is to it! Happy module-switching!
The final step in setting up the application is to
configure the
application deployment descriptor (stored in file
WEB-INF/web.xml
) to include all the framework or Taglib components that
are required.
Using the deployment descriptor for the example
application as a guide,
we see that the following entries need to be created or
modified.
Add an entry defining the action servlet itself, along with the appropriate initialization parameters. Such an entry might look like this:
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>
org.apache.struts.action.ActionServlet
</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>
/WEB-INF/struts-config.xml
</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
The initialization parameters supported by the action servlet are described below. (You can also find these details in the Javadocs for the ActionServlet class.) Square brackets describe the default values that are assumed if you do not provide a value for that initialization parameter.
java.lang.Integer
) will default to null (rather than 0).
(Since version 1.1) [false]
org.apache.commons.digester.RuleSet
instances that
should be added to the
Digester
that will be processing
struts-config.xml
files.
By default, only the
RuleSet
for the standard
configuration elements is loaded. (Since version 1.1)
WARNING
- The framework will not
operate correctly if you define more than one
<servlet>
element for a controller
servlet, or a subclass of the standard controller servlet
class.
The controller servlet
MUST
be a web application
wide singleton.
Note: The material in this section is not specific to Struts. The configuration of servlet mappings is defined in the Java Servlet Specification. This section describes the most common means of configuring a application.
There are two common approaches to defining the URLs that will be processed by the controller servlet -- prefix matching and extension matching. An appropriate mapping entry for each approach will be described below.
Prefix matching means that you want all URLs that start (after the context path part) with a particular value to be passed to this servlet. Such an entry might look like this:
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>/do/*</url-pattern>
</servlet-mapping>
which means that a request URI to match the
/logon
path
described earlier might look like this:
http://www.mycompany.com/myapplication/do/logon
where
/myapplication
is the context path under which your
application is deployed.
Extension mapping, on the other hand, matches request URIs
to the
action servlet based on the fact that the URI ends with a
period
followed by a defined set of characters.
For example, the JSP processing servlet is mapped
to the
*.jsp
pattern so that it is called to process
every JSP page that is requested.
To use the
*.do
extension (which implies "do something"),
the mapping entry would look like this:
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
and a request URI to match the
/logon
path described
earlier might look like this:
http://www.mycompany.com/myapplication/logon.do
WARNING
- The framework will not
operate correctly if you define more than one
<servlet-mapping>
element for the controller
servlet.
WARNING - If you are using the new module support since version 1.1, you should be aware that only extension mapping is supported.
The Servlet 2.3 and 2.4 specifications simplify the
deployment and configuration of tag libraries.
All that's now required to install the Struts tag
libraries is to copy
struts-taglib.jar
into your
/WEB-INF/lib
directory and reference the tags in
your code like this:
<%@ taglib
uri="http://struts.apache.org/tags-html"
prefix="html" %>
Note that you
must use the full uri
defined in the various
tlds (see the
example configuration
for reference)
so that the container knows where to find the tag's class
files.
You don't have to alter your
web.xml
file or copy tlds into any
application directories.
Of course, the configuration techniques use for older containers do still work.
To use the framework, you must copy
struts-core-*.jar
(and all of the
commons-*.jar
files) into your
WEB-INF/lib
directory. To use Struts Taglib,
you must also copy the
struts-taglib-*.jar.
Likewise, to use other optional components, like
Extras, Tiles, or the Validator, copy the corresponding
struts-*.jar.
Many servlet containers and application servers
provide facilities
for sharing JAR files across multiple web applications
that depend
on them. For example, Tomcat 4.1 allows you to put JAR
files into
the
$CATALINA_HOME/shared/lib
or
$CATALINA_HOME/common/lib
directories, and the classes
in those JAR files will be available in all
applications, without
the need to place them in every web application's
/WEB-INF/lib
directory. Usually, the sharing is
accomplished by creating a separate class loader that
is the parent
of the class loader (created by your container) for
each individual
web application.
If you have multiple web applications based on the framework,
it is tempting
to consider taking advantage of this container
feature, and placing
struts.jar
and the various
commons-*.jar
files in the shared directory, rather than in each web
application.
However, there are several potential, and actual,
problems with this approach:
In spite of these difficulties, it is possible that sharing the Struts and Commons JAR files might appear to work for you. However, this is NOT a supported configuration.
If you file a bug report for
ClassNotFoundException
or
NoClassDefFoundError
exceptions, or similar situations
where it appears that the wrong version of a class is
being loaded,
the bug report will
NOT
be processed unless the
problem exists with the JAR files in their recommended
location,
in the
/WEB-INF/lib
subdirectory of your webapp.
Since version 1.0, the logging functionality was fairly
limited. You could
set a debugging detail level with a servlet initialization
parameter, and
all log messages were written to wherever
ServletContext.log()
output is sent by your servlet container. With Struts 1.1,
however, all
logging messages written by the framework, as well as the
commons libraries
that it utilizes, flow through an abstract wrapper called
Commons Logging,
which can be used as a wrapper around any logging
implementation. The most
common implementations used are simple logging to
System.err,
the
Apache
Log4J
package,
or the built-in logging capabilities of JDK 1.4 or later
in the
java.util.logging
package.
This section does not attempt to fully explain how Commons Logging is configured and used. Instead, it focuses on pertinent details of using Commons Logging in connection with the Struts Framework. For complete documentation on using Commons Logging, consult the documentation for the logging system you are using, plus the Commons Logging Javadocs.
Commons Logging provides fine-grained control over the
logging messages
created by a
Log
instance. By convention, the
Log
instances for the framework (and the Commons packages in
general) are named the
fully qualified class name of the class whose messages are
being logged.
Therefore, log messages created by the
RequestProcessor
class are, naturally
enough, directed to a logger named
org.apache.struts.action.RequestProcessor.
The advantage of this approach is that you can configure
the level of detail
in the output you want from each class, individually.
However, it would be
a burden to be required to maintain such settings for
every possible class,
so the logging environment supports the notion of logging
hierarchies
as well. If a detail level configuration for a
particular class has not been set, the logging system
looks up the hierarchy
until it finds a configuration setting to use, or else
uses the default
detail level if no configuration for any level of the
hierarchy has been
explicitly set. In the case of our messages from
RequestProcessor,
the logging system will look for explicit settings of the
following loggers,
in this order, until it finds one:
org.apache.struts.action.RequestProcessororg.apache.struts.actionorg.apache.strutsorg.apacheorg
In a similar manner, the detail level for messages from
PropertyUtils
(from the Commons BeanUtils library) is set by
a search for configuration settings for:
org.apache.commons.beanutils.PropertyUtilsorg.apache.commons.beanutilsorg.apache.commonsorg.apacheorgYou can seamlessly integrate logging from your own components into the same logging implementation that the framework and the Commons libraries use, by following the instructions in Section 4.11 . If you do this, you are strongly encouraged to follow the same naming convention for loggers (based on the class name of the messages being logged) for maximum configuration flexibility.