ComposableRequestProcessor xref

View Javadoc

    1   /*
    2    * $Id: ComposableRequestProcessor.java 471754 2006-11-06 14:55:09Z husted $
    3    *
    4    * Licensed to the Apache Software Foundation (ASF) under one
    5    * or more contributor license agreements.  See the NOTICE file
    6    * distributed with this work for additional information
    7    * regarding copyright ownership.  The ASF licenses this file
    8    * to you under the Apache License, Version 2.0 (the
    9    * "License"); you may not use this file except in compliance
    10   * with the License.  You may obtain a copy of the License at
    11   *
    12   *  http://www.apache.org/licenses/LICENSE-2.0
    13   *
    14   * Unless required by applicable law or agreed to in writing,
    15   * software distributed under the License is distributed on an
    16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    17   * KIND, either express or implied.  See the License for the
    18   * specific language governing permissions and limitations
    19   * under the License.
    20   */
    21  package org.apache.struts.chain;
    22
    23  import org.apache.commons.beanutils.ConstructorUtils;
    24  import org.apache.commons.chain.Catalog;
    25  import org.apache.commons.chain.CatalogFactory;
    26  import org.apache.commons.chain.Command;
    27  import org.apache.commons.logging.Log;
    28  import org.apache.commons.logging.LogFactory;
    29  import org.apache.struts.action.ActionServlet;
    30  import org.apache.struts.action.RequestProcessor;
    31  import org.apache.struts.chain.contexts.ActionContext;
    32  import org.apache.struts.chain.contexts.ServletActionContext;
    33  import org.apache.struts.config.ControllerConfig;
    34  import org.apache.struts.config.ModuleConfig;
    35  import org.apache.struts.upload.MultipartRequestWrapper;
    36  import org.apache.struts.util.RequestUtils;
    37
    38  import javax.servlet.ServletContext;
    39  import javax.servlet.ServletException;
    40  import javax.servlet.UnavailableException;
    41  import javax.servlet.http.HttpServletRequest;
    42  import javax.servlet.http.HttpServletResponse;
    43
    44  import java.io.IOException;
    45
    46  import java.lang.reflect.Constructor;
    47
    48  /**
    49   * <p> ComposableRequestProcessor uses the Chain Of Resposibility design
    50   * pattern (as implemented by the commons-chain package in Jakarta Commons) to
    51   * support external configuration of command chains to be used.  It is
    52   * configured via the following context initialization parameters: </p>
    53   *
    54   * <ul>
    55   *
    56   * <li>[org.apache.struts.chain.CATALOG_NAME] - Name of the Catalog in which
    57   * we will look up the Command to be executed for each request.  If not
    58   * specified, the default value is struts. </li>
    59   *
    60   * <li> org.apache.struts.chain.COMMAND_NAME - Name of the Command which we
    61   * will execute for each request, to be looked up in the specified Catalog.
    62   * If not specified, the default value is servlet-standard. </li>
    63   *
    64   * </ul>
    65   *
    66   * @version $Rev: 471754 $ $Date: 2005-11-12 13:01:44 -0500 (Sat, 12 Nov 2005)
    67   *          $
    68   * @since Struts 1.1
    69   */
    70  public class ComposableRequestProcessor extends RequestProcessor {
    71      // ------------------------------------------------------ Instance Variables
    72
    73      /**
    74       * <p> Cache for constructor discovered by setActionContextClass method.
    75       * </p>
    76       */
    77      private static final Class[] SERVLET_ACTION_CONTEXT_CTOR_SIGNATURE =
    78          new Class[] {
    79              ServletContext.class, HttpServletRequest.class,
    80              HttpServletResponse.class
    81          };
    82
    83      /**
    84       * <p> Token for ActionContext clazss so that it can be stored in the
    85       * ControllerConfig. </p>
    86       */
    87      public static final String ACTION_CONTEXT_CLASS = "ACTION_CONTEXT_CLASS";
    88
    89      /**
    90       * <p>The <code>Log</code> instance for this class.</p>
    91       */
    92      protected static final Log LOG =
    93          LogFactory.getLog(ComposableRequestProcessor.class);
    94
    95      /**
    96       * <p>The {@link CatalogFactory} from which catalog containing the the
    97       * base request-processing {@link Command} will be retrieved.</p>
    98       */
    99      protected CatalogFactory catalogFactory = null;
    100
    101     /**
    102      * <p>The {@link Catalog} containing all of the available command chains
    103      * for this module.
    104      */
    105     protected Catalog catalog = null;
    106
    107     /**
    108      * <p>The {@link Command} to be executed for each request.</p>
    109      */
    110     protected Command command = null;
    111
    112     /**
    113      * <p> ActionContext class as cached by createActionContextInstance
    114      * method. </p>
    115      */
    116     private Class actionContextClass;
    117
    118     /**
    119      * <p> ActionContext constructor as cached by createActionContextInstance
    120      * method. </p>
    121      */
    122     private Constructor servletActionContextConstructor = null;
    123
    124     // ---------------------------------------------------------- Public Methods
    125
    126     /**
    127      * <p>Clean up in preparation for a shutdown of this application.</p>
    128      */
    129     public void destroy() {
    130         super.destroy();
    131         catalogFactory = null;
    132         catalog = null;
    133         command = null;
    134         actionContextClass = null;
    135         servletActionContextConstructor = null;
    136     }
    137
    138     /**
    139      * <p>Initialize this request processor instance.</p>
    140      *
    141      * @param servlet      The ActionServlet we are associated with
    142      * @param moduleConfig The ModuleConfig we are associated with.
    143      * @throws ServletException If an error occurs during initialization
    144      */
    145     public void init(ActionServlet servlet, ModuleConfig moduleConfig)
    146         throws ServletException {
    147         LOG.info(
    148             "Initializing composable request processor for module prefix '"
    149             + moduleConfig.getPrefix() + "'");
    150         super.init(servlet, moduleConfig);
    151
    152         initCatalogFactory(servlet, moduleConfig);
    153
    154         ControllerConfig controllerConfig = moduleConfig.getControllerConfig();
    155
    156         String catalogName = controllerConfig.getCatalog();
    157
    158         catalog = this.catalogFactory.getCatalog(catalogName);
    159
    160         if (catalog == null) {
    161             throw new ServletException("Cannot find catalog '" + catalogName
    162                 + "'");
    163         }
    164
    165         String commandName = controllerConfig.getCommand();
    166
    167         command = catalog.getCommand(commandName);
    168
    169         if (command == null) {
    170             throw new ServletException("Cannot find command '" + commandName
    171                 + "'");
    172         }
    173
    174         this.setActionContextClassName(controllerConfig.getProperty(
    175                 ACTION_CONTEXT_CLASS));
    176     }
    177
    178     /**
    179      * <p> Set and cache ActionContext class. </p><p> If there is a custom
    180      * class provided and if it uses our "preferred" constructor, cache a
    181      * reference to that constructor rather than looking it up every time.
    182      * </p>
    183      *
    184      * @param actionContextClass The ActionContext class to process
    185      */
    186     private void setActionContextClass(Class actionContextClass) {
    187         this.actionContextClass = actionContextClass;
    188
    189         if (actionContextClass != null) {
    190             this.servletActionContextConstructor =
    191                 ConstructorUtils.getAccessibleConstructor(actionContextClass,
    192                     SERVLET_ACTION_CONTEXT_CTOR_SIGNATURE);
    193         } else {
    194             this.servletActionContextConstructor = null;
    195         }
    196     }
    197
    198     /**
    199      * <p>Make sure that the specified <code>className</code> identfies a
    200      * class which can be found and which implements the
    201      * <code>ActionContext</code> interface.</p>
    202      *
    203      * @param className Fully qualified name of
    204      * @throws ServletException     If an error occurs during initialization
    205      * @throws UnavailableException if class does not implement ActionContext
    206      *                              or is not found
    207      */
    208     private void setActionContextClassName(String className)
    209         throws ServletException {
    210         if ((className != null) && (className.trim().length() > 0)) {
    211             if (LOG.isDebugEnabled()) {
    212                 LOG.debug(
    213                     "setActionContextClassName: requested context class: "
    214                     + className);
    215             }
    216
    217             try {
    218                 Class actionContextClass =
    219                     RequestUtils.applicationClass(className);
    220
    221                 if (!ActionContext.class.isAssignableFrom(actionContextClass)) {
    222                     throw new UnavailableException("ActionContextClass " + "["
    223                         + className + "]"
    224                         + " must implement ActionContext interface.");
    225                 }
    226
    227                 this.setActionContextClass(actionContextClass);
    228             } catch (ClassNotFoundException e) {
    229                 throw new UnavailableException("ActionContextClass "
    230                     + className + " not found.");
    231             }
    232         } else {
    233             if (LOG.isDebugEnabled()) {
    234                 LOG.debug("setActionContextClassName: no className specified");
    235             }
    236
    237             this.setActionContextClass(null);
    238         }
    239     }
    240
    241     /**
    242      * <p> Establish the CatalogFactory which will be used to look up the
    243      * catalog which has the request processing command. </p><p> The base
    244      * implementation simply calls CatalogFactory.getInstance(), unless the
    245      * catalogFactory property of this object has already been set, in which
    246      * case it is not changed. </p>
    247      *
    248      * @param servlet      The ActionServlet we are processing
    249      * @param moduleConfig The ModuleConfig we are processing
    250      */
    251     protected void initCatalogFactory(ActionServlet servlet,
    252         ModuleConfig moduleConfig) {
    253         if (this.catalogFactory != null) {
    254             return;
    255         }
    256
    257         this.catalogFactory = CatalogFactory.getInstance();
    258     }
    259
    260     /**
    261      * <p>Process an <code>HttpServletRequest</code> and create the
    262      * corresponding <code>HttpServletResponse</code>.</p>
    263      *
    264      * @param request  The servlet request we are processing
    265      * @param response The servlet response we are creating
    266      * @throws IOException      if an input/output error occurs
    267      * @throws ServletException if a processing exception occurs
    268      */
    269     public void process(HttpServletRequest request, HttpServletResponse response)
    270         throws IOException, ServletException {
    271         // Wrap the request in the case of a multipart request
    272         request = processMultipart(request);
    273
    274         // Create and populate a Context for this request
    275         ActionContext context = contextInstance(request, response);
    276
    277         // Create and execute the command.
    278         try {
    279             if (LOG.isDebugEnabled()) {
    280                 LOG.debug("Using processing chain for this request");
    281             }
    282
    283             command.execute(context);
    284         } catch (Exception e) {
    285             // Execute the exception processing chain??
    286             throw new ServletException(e);
    287         }
    288
    289         // Release the context.
    290         context.release();
    291     }
    292
    293     /**
    294      * <p>Provide the initialized <code>ActionContext</code> instance which
    295      * will be used by this request. Internally, this simply calls
    296      * <code>createActionContextInstance</code> followed by
    297      * <code>initializeActionContext</code>.</p>
    298      *
    299      * @param request  The servlet request we are processing
    300      * @param response The servlet response we are creating
    301      * @return Initiliazed ActionContext
    302      * @throws ServletException if a processing exception occurs
    303      */
    304     protected ActionContext contextInstance(HttpServletRequest request,
    305         HttpServletResponse response)
    306         throws ServletException {
    307         ActionContext context =
    308             createActionContextInstance(getServletContext(), request, response);
    309
    310         initializeActionContext(context);
    311
    312         return context;
    313     }
    314
    315     /**
    316      * <p>Create a new instance of <code>ActionContext</code> according to
    317      * configuration.  If no alternative was specified at initialization, a
    318      * new instance <code>ServletActionContext</code> is returned.  If an
    319      * alternative was specified using the <code>ACTION_CONTEXT_CLASS</code>
    320      * property, then that value is treated as a classname, and an instance of
    321      * that class is created.  If that class implements the same constructor
    322      * that <code>ServletActionContext</code> does, then that constructor will
    323      * be used: <code>ServletContext, HttpServletRequest,
    324      * HttpServletResponse</code>; otherwise, it is assumed that the class has
    325      * a no-arguments constructor.  If these constraints do not suit you,
    326      * simply override this method in a subclass.</p>
    327      *
    328      * @param servletContext The servlet context we are processing
    329      * @param request        The servlet request we are processing
    330      * @param response       The servlet response we are creating
    331      * @return New instance of ActionContext
    332      * @throws ServletException if a processing exception occurs
    333      */
    334     protected ActionContext createActionContextInstance(
    335         ServletContext servletContext, HttpServletRequest request,
    336         HttpServletResponse response)
    337         throws ServletException {
    338         if (this.actionContextClass == null) {
    339             return new ServletActionContext(servletContext, request, response);
    340         }
    341
    342         try {
    343             if (this.servletActionContextConstructor == null) {
    344                 return (ActionContext) this.actionContextClass.newInstance();
    345             }
    346
    347             return (ActionContext) this.servletActionContextConstructor
    348             .newInstance(new Object[] { servletContext, request, response });
    349         } catch (Exception e) {
    350             throw new ServletException(
    351                 "Error creating ActionContext instance of type "
    352                 + this.actionContextClass, e);
    353         }
    354     }
    355
    356     /**
    357      * <p>Set common properties on the given <code>ActionContext</code>
    358      * instance so that commands in the chain can count on their presence.
    359      * Note that while this method does not require that its argument be an
    360      * instance of <code>ServletActionContext</code>, at this time many common
    361      * Struts commands will be expecting to receive an <code>ActionContext</code>
    362      * which is also a <code>ServletActionContext</code>.</p>
    363      *
    364      * @param context The ActionContext we are processing
    365      */
    366     protected void initializeActionContext(ActionContext context) {
    367         if (context instanceof ServletActionContext) {
    368             ((ServletActionContext) context).setActionServlet(this.servlet);
    369         }
    370
    371         context.setModuleConfig(this.moduleConfig);
    372     }
    373
    374     /**
    375      * <p>If this is a multipart request, wrap it with a special wrapper.
    376      * Otherwise, return the request unchanged.</p>
    377      *
    378      * @param request The HttpServletRequest we are processing
    379      * @return Original or wrapped request as appropriate
    380      */
    381     protected HttpServletRequest processMultipart(HttpServletRequest request) {
    382         if (!"POST".equalsIgnoreCase(request.getMethod())) {
    383             return (request);
    384         }
    385
    386         String contentType = request.getContentType();
    387
    388         if ((contentType != null)
    389             && contentType.startsWith("multipart/form-data")) {
    390             return (new MultipartRequestWrapper(request));
    391         } else {
    392             return (request);
    393         }
    394     }
    395
    396     /**
    397      * <p>Set the <code>CatalogFactory</code> instance which should be used to
    398      * find the request-processing command.  In the base implementation, if
    399      * this value is not already set, then it will be initialized when {@link
    400      * #initCatalogFactory} is called. </p>
    401      *
    402      * @param catalogFactory Our CatalogFactory instance
    403      */
    404     public void setCatalogFactory(CatalogFactory catalogFactory) {
    405         this.catalogFactory = catalogFactory;
    406     }
    407 }