Java tutorial
/* * $Id: ActionDispatcher.java 383720 2006-03-07 00:07:59Z niallp $ * * Copyright 2005-2006 The Apache Software Foundation. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.struts.actions; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.HashMap; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.struts.action.Action; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import org.apache.struts.util.MessageResources; import org.apache.struts.Globals; /** * <p>Action <i>helper</i> class that dispatches to a public method in an Action.</p> * <p/> * <p>This class is provided as an alternative mechanism to using DispatchAction * and its various flavours and means <i>Dispatch</i> behaviour can be * easily implemented into any <code>Action</code> without having to * inherit from a particular super <code>Action</code>.</p> * <p/> * <p>To implement <i>dispatch</i> behaviour</i> in an <code>Action</code> class, * create your custom Action as follows, along with the methods you * require (and optionally "cancelled" and "unspecified" methods):</p> * <p/> * <pre> * public class MyCustomAction extends Action { * * protected ActionDispatcher dispatcher * = new ActionDispatcher(this, ActionDispatcher.MAPPING_FLAVOR); * * public ActionForward execute(ActionMapping mapping, * ActionForm form, * HttpServletRequest request, * HttpServletResponse response) * throws Exception { * return dispatcher.execute(mapping, form, request, response); * } * } * </pre> * <p/> * <p>It provides three flavours of determing the name of the method:</p> * <p/> * <ul> * <li><strong>{@link #DEFAULT_FLAVOR}</strong> - uses the parameter specified in * the struts-config.xml to get the method name from the Request * (equivalent to <code>DispatchAction</code> <b>except</b> uses "method" * as a default if the <code>parameter</code> is not specified * in the struts-config.xml).</li> * <p/> * <li><strong>{@link #DISPATCH_FLAVOR}</strong> - uses the parameter specified in * the struts-config.xml to get the method name from the Request * (equivalent to <code>DispatchAction</code>).</li> * <p/> * <li><strong>{@link #MAPPING_FLAVOR}</strong> - uses the parameter specified in * the struts-config.xml as the method name * (equivalent to <code>MappingDispatchAction</code>).</li> * <p/> * </ul> * * @since Struts 1.2.7 * @version $Revision: 383720 $ $Date: 2006-03-07 00:07:59 +0000 (Tue, 07 Mar 2006) $ */ public class ActionDispatcher { // ----------------------------------------------------- Instance Variables /** * Indicates "default" dispatch flavor */ public static final int DEFAULT_FLAVOR = 0; /** * Indicates "mapping" dispatch flavor */ public static final int MAPPING_FLAVOR = 1; /** * Indicates flavor compatible with DispatchAction */ public static final int DISPATCH_FLAVOR = 2; /** * The associated Action to dispatch to. */ protected Action actionInstance; /** * Indicates dispatch <i>flavor</i> */ protected int flavor; /** * The Class instance of this <code>DispatchAction</code> class. */ protected Class clazz; /** * Commons Logging instance. */ protected static Log log = LogFactory.getLog(ActionDispatcher.class); /** * The message resources for this package. */ protected static MessageResources messages = MessageResources .getMessageResources("org.apache.struts.actions.LocalStrings"); /** * 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 = { ActionMapping.class, ActionForm.class, HttpServletRequest.class, HttpServletResponse.class }; // ----------------------------------------------------- Constructors public ActionDispatcher(Action actionInstance) { this(actionInstance, DEFAULT_FLAVOR); } public ActionDispatcher(Action actionInstance, int flavor) { this.actionInstance = actionInstance; this.flavor = flavor; clazz = actionInstance.getClass(); } // --------------------------------------------------------- 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 <code>ActionForward</code> instance describing where and how * control should be forwarded, or <code>null</code> if the response has * already been completed. * * @param mapping The ActionMapping used to select this instance * @param form The optional ActionForm bean for this request (if any) * @param request The HTTP request we are processing * @param response The HTTP response we are creating * @throws Exception if an exception occurs */ 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); } /** * <p>Dispatches to the target class' <code>unspecified</code> method, * if present, otherwise throws a ServletException. Classes utilizing * <code>ActionDispatcher</code> should provide an <code>unspecified</code> * method if they wish to provide behavior different than * throwing a ServletException..</p> */ 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); } /** * <p>Dispatches to the target class' cancelled method, if present, * otherwise returns null. Classes utilizing <code>ActionDispatcher</code> * should provide a <code>cancelled</code> method if they wish to provide * behavior different than returning null.</p> */ 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); } // ----------------------------------------------------- Protected Methods /** * Dispatch to the specified method. */ 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); } /** * Introspect the current class to identify a method of the specified * name that accepts the same parameter types as the <code>execute</code> * method does. * * @param name Name of the method to be introspected * @throws 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); } } /** * <p>Returns the parameter value as influenced by the selected * {@link #flavor} specified for this <code>ActionDispatcher</code>.</p> * * @param mapping The ActionMapping used to select this instance * @param form The optional ActionForm bean for this request (if any) * @param request The HTTP request we are processing * @param response The HTTP response we are creating * @return The <code>ActionMapping</code> 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 method name, given a parameter's value. * * @param mapping The ActionMapping used to select this instance * @param form The optional ActionForm bean for this request (if any) * @param request The HTTP request we are processing * @param response The HTTP response we are creating * @param parameter The <code>ActionMapping</code> parameter's name * @return The method's name. */ 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); } /** * <p>Returns <code>true</code> if the current form's cancel button was * pressed. This method will check if the <code>Globals.CANCEL_KEY</code> * request attribute has been set, which normally occurs if the cancel * button generated by <strong>CancelTag</strong> was pressed by the user * in the current request. If <code>true</code>, validation performed * by an <strong>ActionForm</strong>'s <code>validate()</code> method * will have been skipped by the controller servlet.</p> * * @param request The servlet request we are processing * @see org.apache.struts.taglib.html.CancelTag */ protected boolean isCancelled(HttpServletRequest request) { return (request.getAttribute(Globals.CANCEL_KEY) != null); } }