public ActionDispatcher(Action actionInstance) 
{
        this(actionInstance, DEFAULT_FLAVOR);
}

 public ActionDispatcher(Action actionInstance,
    int flavor) 
{
        this.actionInstance = actionInstance;
        this.flavor = flavor;
        clazz = actionInstance.getClass();
}

 protected ActionForward cancelled(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response) throws Exception 
{
        // Identify if there is an "cancelled" method to be dispatched to
        String name = "cancelled";
        Method method = null;
        try {
            method = getMethod(name);
        } catch (NoSuchMethodException e) {
            return null;
        }
        return dispatchMethod(mapping, form, request, response, name, method);
}

Dispatches to the target class' cancelled method, if present, otherwise returns null. Classes utilizing ActionDispatcher should provide a cancelled method if they wish to provide behavior different than returning null.

 protected ActionForward dispatchMethod(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response,
    String name) throws Exception 
{
        // Make sure we have a valid method name to call.
        // This may be null if the user hacks the query string.
        if (name == null) {
            return this.unspecified(mapping, form, request, response);
        }
        // Identify the method object to be dispatched to
        Method method = null;
        try {
            method = getMethod(name);
        } catch (NoSuchMethodException e) {
            String message =
                    messages.getMessage("dispatch.method", mapping.getPath(), name);
            log.error(message, e);
            String userMsg =
                messages.getMessage("dispatch.method.user", mapping.getPath());
            throw new NoSuchMethodException(userMsg);
        }
        return dispatchMethod(mapping, form, request, response, name, method);
}

Dispatch to the specified method.

 protected ActionForward dispatchMethod(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response,
    String name,
    Method method) throws Exception 
{
        ActionForward forward = null;
        try {
            Object args[] = {mapping, form, request, response};
            forward = (ActionForward) method.invoke(actionInstance, args);
        } catch (ClassCastException e) {
            String message =
                    messages.getMessage("dispatch.return", mapping.getPath(), name);
            log.error(message, e);
            throw e;
        } catch (IllegalAccessException e) {
            String message =
                    messages.getMessage("dispatch.error", mapping.getPath(), name);
            log.error(message, e);
            throw e;
        } catch (InvocationTargetException e) {
            // Rethrow the target exception if possible so that the
            // exception handling machinery can deal with it
            Throwable t = e.getTargetException();
            if (t instanceof Exception) {
                throw ((Exception) t);
            } else {
                String message =
                        messages.getMessage("dispatch.error", mapping.getPath(), name);
                log.error(message, e);
                throw new ServletException(t);
            }
        }
        // Return the returned ActionForward instance
        return (forward);
}

Dispatch to the specified method.

 public ActionForward execute(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response) throws Exception 
{
        // Process "cancelled"
        if (isCancelled(request)) {
            ActionForward af = cancelled(mapping, form, request, response);
            if (af != null) {
                return af;
            }
        }
        // Identify the request parameter containing the method name
        String parameter = getParameter(mapping, form, request, response);
        // Get the method's name. This could be overridden in subclasses.
        String name = getMethodName(mapping, form, request, response, parameter);
        // Prevent recursive calls
        if ("execute".equals(name) || "perform".equals(name)) {
            String message =
                    messages.getMessage("dispatch.recursive", mapping.getPath());
            log.error(message);
            throw new ServletException(message);
        }
        // Invoke the named method, and return the result
        return dispatchMethod(mapping, form, request, response, name);
}

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.

 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);
        }
}

Introspect the current class to identify a method of the specified name that accepts the same parameter types as the execute method does.

 protected String getMethodName(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response,
    String parameter) throws Exception 
{
        // "Mapping" flavor, defaults to "method"
        if (flavor == MAPPING_FLAVOR) {
            return parameter;
        }
        // default behaviour
        return request.getParameter(parameter);
}

Returns the method name, given a parameter's value.

 protected String getParameter(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response) throws Exception 
{
        String parameter = mapping.getParameter();
        if ("".equals(parameter)) {
            parameter = null;
        }
        if ((parameter == null) && (flavor == DEFAULT_FLAVOR)) {
            // use "method" for DEFAULT_FLAVOR if no parameter was provided
            return "method";
        }
        if ((parameter == null) &&
                ((flavor == MAPPING_FLAVOR || flavor == DISPATCH_FLAVOR))) {
            String message =
                    messages.getMessage("dispatch.handler", mapping.getPath());
            log.error(message);
            throw new ServletException(message);
        }
        return parameter;
}

Returns the parameter value as influenced by the selected #flavor specified for this ActionDispatcher.

 protected boolean isCancelled(HttpServletRequest request) 
{
        return (request.getAttribute(Globals.CANCEL_KEY) != null);
}

Returns true if the current form's cancel button was pressed. This method will check if the Globals.CANCEL_KEY request attribute has been set, which normally occurs if the cancel button generated by CancelTag was pressed by the user in the current request. If true, validation performed by an ActionForm's validate() method will have been skipped by the controller servlet.

 protected ActionForward unspecified(ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response) throws Exception 
{
        // Identify if there is an "unspecified" method to be dispatched to
        String name = "unspecified";
        Method method = null;
        try {
            method = getMethod(name);
        } catch (NoSuchMethodException e) {
            String message = messages.getMessage("dispatch.parameter",
                    mapping.getPath(),
                    mapping.getParameter());
            log.error(message);
            throw new ServletException(message);
        }
        return dispatchMethod(mapping, form, request, response, name, method);
}

Dispatches to the target class' unspecified method, if present, otherwise throws a ServletException. Classes utilizing ActionDispatcher should provide an unspecified method if they wish to provide behavior different than throwing a ServletException..