org.apache.struts.actions: abstract public class: LookupDispatchAction

org.apache.struts.actions
abstract public class: LookupDispatchAction [javadoc | source]

java.lang.Object
   org.apache.struts.action.Action
      org.apache.struts.actions.DispatchAction
         org.apache.struts.actions.LookupDispatchAction

An abstract Action that dispatches to the subclass mapped execute method. 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="method"/>

which will use the value of the request parameter named "method" 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="method">
<bean:message key="button.add"/>
</html:submit>
<html:submit property="method">
<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() {
Map map = new HashMap();
map.put("button.add", "add");
map.put("button.delete", "delete");
return map;
}

public ActionForward add(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
// do add
return mapping.findForward("success");
}

public ActionForward delete(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
// do delete
return mapping.findForward("success");
}


Notes - If duplicate values exist for the keys returned by
getKeys, only the first one found will be returned. If no corresponding key
is found then an exception will be thrown. You can override the
method unspecified to provide a custom handler. If the submit
was cancelled (a html:cancel button was pressed), the custom
handler cancelled will be used instead.








    







    
Field Summary
protected   Map  localeMap    Reverse lookup map from resource value to resource key. 
protected   Map  keyMethodMap    Resource key to method name lookup. 
Fields inherited from org.apache.struts.actions.DispatchAction: 
 clazz,  log,  messages,  methods,  types











    











    Method from org.apache.struts.actions.LookupDispatchAction Summary:

execute,   getKeyMethodMap,   getLookupMapName,   getMethodName
Methods from org.apache.struts.actions.DispatchAction:

cancelled,   dispatchMethod,   execute,   getMethod,   getMethodName,   getParameter,   unspecified
Methods from java.lang.Object:

equals,   getClass,   hashCode,   notify,   notifyAll,   toString,   wait,   wait,   wait
Method from org.apache.struts.actions.LookupDispatchAction Detail:
 public ActionForward execute(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response) throws Exception {
    // ---------------------------------------------------------- Public Methods
        return super.execute(mapping, form, request, response);
}
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.
 abstract protected Map getKeyMethodMap()Provides the mapping from resource key to method name.
 protected String getLookupMapName(HttpServletRequest request,
    String keyName,
    ActionMapping mapping) throws ServletException {
        // Based on this request's Locale get the lookupMap
        Map lookupMap = null;
        synchronized(localeMap) {
            Locale userLocale = this.getLocale(request);
            lookupMap = (Map) this.localeMap.get(userLocale);
            if (lookupMap == null) {
                lookupMap = this.initLookupMap(request, userLocale);
                this.localeMap.put(userLocale, lookupMap);
            }
        }
        // Find the key for the resource
        String key = (String) lookupMap.get(keyName);
        if (key == null) {
            String message =
                messages.getMessage("dispatch.resource", mapping.getPath());
            LOG.error(message + " '" + keyName + "'");
            throw new ServletException(message);
        }
        // Find the method name
        String methodName = (String) keyMethodMap.get(key);
        if (methodName == null) {
            String message = messages.getMessage(
                    "dispatch.lookup", mapping.getPath(), key);
            throw new ServletException(message);
        }
        return methodName;
}
Lookup the method name corresponding to the client request's locale.
 protected String getMethodName(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response,
    String parameter) throws Exception {
        // Identify the method name to be dispatched to.
        // dispatchMethod() will call unspecified() if name is null
        String keyName = request.getParameter(parameter);
        if (keyName == null || keyName.length() == 0) {
            return null;
        }
        String methodName = getLookupMapName(request, keyName, mapping);
        return methodName;
}
Returns the method name, given a parameter's value.

Field Summary
protected Map	localeMap	Reverse lookup map from resource value to resource key.
protected Map	keyMethodMap	Resource key to method name lookup.