*
* An abstract Action that dispatches to the subclass keyed
* perform method, passing a key from ApplicationResources. This is useful in
* cases where an HTML form has multiple submit buttons with the same name. The
* button name is specified by the parameter property of the
* corresponding ActionMapping. To configure the use of this action in your
* struts-config.xml file, create an entry like this:
* <action path="/test" * type="org.example.MyAction" * name="MyForm" * scope="request" * input="/test.jsp" * parameter="action"/> *
* * which will use the value of the request parameter named "action" to locate * the corresponding key in ApplicationResources. For example, you might have * the following ApplicationResources.properties:
* button.add=Add Record * button.delete=Delete Record *
* * And your JSP would have the following format for submit buttons:
* <html:form action="/test"> * <html:submit property="action"> * <bean:message key="button.add"/> * </html:submit> * <html:submit property="action"> * <bean:message key="button.delete"/> * </html:submit> * </html:form> *
* * Your subclass must implement both getKeyMethodMap and the methods defined in * the map. An example of such implementations are:
* protected Map getKeyMethodMap(ActionMapping mapping,
* ActionForm form,
* HttpServletRequest request) {
* Map map = new HashMap();
* map.put("button.add", "add");
* map.put("button.delete", "delete");
* return map;
* }
*
* public ActionForward add(String key, ActionMapping mapping,
* ActionForm form,
* HttpServletRequest request,
* HttpServletResponse response)
* throws IOException, ServletException {
* // do add
* return mapping.findForward("success");
* }
*
* public ActionForward delete(String key, ActionMapping mapping,
* ActionForm form,
* HttpServletRequest request,
* HttpServletResponse response)
* throws IOException, ServletException {
* // do delete
* return mapping.findForward("success");
* }
*
* The method invoked would receive either "button.add" or "button.delete" as
* the key.
*
*
* Notes - If duplicate values exist for the keys returned by
* getKeyMethodMap, only the first one found will be returned. If no
* corresponding key is found then an exception will be thrown.
*
*@author Erik Hatcher
*@created November 14, 2001
*/
public abstract class LookupDispatchMethodAction extends Action {
/**
* The message resources for this package.
*/
protected static MessageResources messages =
MessageResources.getMessageResources("org.apache.struts.actions.LocalStrings");
/**
* The Class instance of this LookupDispatchMethodAction
* class.
*/
protected Class clazz = this.getClass();
/**
* The set of Method objects we have introspected for this class, keyed by
* method name. This collection is populated as different methods are
* called, so that introspection needs to occur only once per method name.
*/
protected HashMap methods = new HashMap();
/**
* The set of argument type classes for the reflected method call. These
* are the same for all calls, so calculate them only once.
*/
protected Class types[] =
{
String.class,
ActionMapping.class,
ActionForm.class,
HttpServletRequest.class,
HttpServletResponse.class};
// ---------------------------------------------------------- Public Methods
/**
* Process the specified HTTP request, and create the corresponding HTTP
* response (or forward to another web component that will create it).
* Return an ActionForward instance describing where and how
* control should be forwarded, or null if the response has
* already been completed.
*
*@param mapping The ActionMapping used to select this
* instance
*@param request The HTTP request we are processing
*@param response The HTTP response we are creating
*@param form The optional ActionForm bean for this
* request (if any)
*@return Describes where and how control should be
* forwarded.
*@exception IOException if an input/output error occurs
*@exception ServletException if a servlet exception occurs, mapping does
* not have a parameter attribute, or the request does not contain the
* attribute named in the mapping parameter.
*/
public ActionForward perform(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
// Identify the request parameter containing the method name
String parameter = mapping.getParameter();
if (parameter == null) {
String message = messages.getMessage("dispatch.handler", mapping.getPath());
throw new ServletException(message);
}
// Identify the string to lookup
String name = request.getParameter(parameter);
if (name == null) {
String message =
messages.getMessage("dispatch.parameter", mapping.getPath(), parameter);
throw new ServletException(message);
}
// Build the key lookup map
Map lookupMap = new HashMap();
Map keyMethodMap = null;
MessageResources resources = servlet.getResources();
keyMethodMap = getKeyMethodMap(mapping, form, request);
Iterator iter = keyMethodMap.keySet().iterator();
while (iter.hasNext()) {
String key = (String) iter.next();
String text = resources.getMessage(key);
if ((text != null) && !lookupMap.containsKey(text)) {
lookupMap.put(text, key);
}
}
// Find the key
String key = (String) lookupMap.get(name);
ActionForward forward = null;
String methodName = (String) keyMethodMap.get(key);
Object args[] = {key, mapping, form, request, response};
forward = invokeMethod(methodName, args, mapping.getPath());
return forward;
}
/**
* The Map of message keys and method name to invoke. The key to each map
* entry is the ApplicationResources key corresponding to the text that
* will be received for the parameter named request attribute. The
* value for each map entry is the name of the method to be invoked when
* the corresponding request attribute was received. The methods must have
* a signature like:
* public ActionForward add(String key, ActionMapping mapping,
* ActionForm form,
* HttpServletRequest request,
* HttpServletResponse response)
* throws IOException, ServletException
*
*
*@param mapping The ActionMapping used to select this instance
*@param form ActionForm associated with this action (if any)
*@param request The HTTP request we are processing
*@return key/method map
*/
protected abstract Map getKeyMethodMap(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request);
/**
* Introspect the current class to identify a method of the specified name
* that accepts the same parameter types as the perform()
* method does.
*
*@param name Name of the method to be introspected
*@return The method object
*@exception NoSuchMethodException if no such method can be found
*/
protected Method getMethod(String name) throws NoSuchMethodException {
synchronized (methods) {
Method method = (Method) methods.get(name);
if (method == null) {
method = clazz.getMethod(name, types);
methods.put(name, method);
}
return (method);
}
}
/**
* Invokes specified method, returning its ActionForward result
*
*@param name Name of method to invoke
*@param args The arguments to the method invoked
*@param mappingPath The mapping path for reporting exceptions
*@return Describes where and how control should be
* forwarded.
*@exception IOException if an input/output error occurs
*@exception ServletException if a servlet exception occurs, which could
* be a result of method not being found or not invokable.
*/
protected ActionForward invokeMethod(
String name,
Object[] args,
String mappingPath)
throws IOException, ServletException {
// Identify the method object to be dispatched to
Method method = null;
try {
method = getMethod(name);
}
catch (NoSuchMethodException e) {
String message = messages.getMessage("dispatch.method", mappingPath, name);
throw new ServletException(message, e);
}
// Dispatch to the specified method
ActionForward forward = null;
try {
forward = (ActionForward) method.invoke(this, args);
}
catch (ClassCastException e) {
String message = messages.getMessage("dispatch.return", mappingPath, name);
throw new ServletException(message, e);
}
catch (IllegalAccessException e) {
String message = messages.getMessage("dispatch.error", mappingPath, name);
throw new ServletException(message, e);
}
catch (InvocationTargetException e) {
String message = messages.getMessage("dispatch.error", mappingPath, name);
throw new ServletException(message, e);
}
return forward;
}
}