Java tutorial
/* * $Id: TilesRequestProcessor.java 471754 2006-11-06 14:55:09Z husted $ * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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.tiles; import java.io.IOException; 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.ActionServlet; import org.apache.struts.action.RequestProcessor; import org.apache.struts.config.ForwardConfig; import org.apache.struts.config.ModuleConfig; /** * <p><strong>RequestProcessor</strong> contains the processing logic that * the Struts controller servlet performs as it receives each servlet request * from the container.</p> * <p>This processor subclasses the Struts RequestProcessor in order to intercept calls to forward * or include. When such calls are done, the Tiles processor checks if the specified URI * is a definition name. If true, the definition is retrieved and included. If * false, the original URI is included or a forward is performed. * <p> * Actually, catching is done by overloading the following methods: * <ul> * <li>{@link #processForwardConfig(HttpServletRequest,HttpServletResponse,ForwardConfig)}</li> * <li>{@link #internalModuleRelativeForward(String, HttpServletRequest , HttpServletResponse)}</li> * <li>{@link #internalModuleRelativeInclude(String, HttpServletRequest , HttpServletResponse)}</li> * </ul> * </p> * @since Struts 1.1 */ public class TilesRequestProcessor extends RequestProcessor { /** * Definitions factory. */ protected DefinitionsFactory definitionsFactory = null; /** * Commons Logging instance. */ protected static Log log = LogFactory.getLog(TilesRequestProcessor.class); /** * Initialize this request processor instance. * * @param servlet The ActionServlet we are associated with. * @param moduleConfig The ModuleConfig we are associated with. * @throws ServletException If an error occurs during initialization. */ public void init(ActionServlet servlet, ModuleConfig moduleConfig) throws ServletException { super.init(servlet, moduleConfig); this.initDefinitionsMapping(); } /** * Read component instance mapping configuration file. * This is where we read files properties. */ protected void initDefinitionsMapping() throws ServletException { // Retrieve and set factory for this modules definitionsFactory = ((TilesUtilStrutsImpl) TilesUtil.getTilesUtil()) .getDefinitionsFactory(getServletContext(), moduleConfig); if (definitionsFactory == null) { // problem ! log.info("Definition Factory not found for module '" + moduleConfig.getPrefix() + "'. " + "Have you declared the appropriate plugin in struts-config.xml ?"); return; } log.info("Tiles definition factory found for request processor '" + moduleConfig.getPrefix() + "'."); } /** * Process a Tile definition name. * This method tries to process the parameter <code>definitionName</code> * as a definition name. * It returns <code>true</code> if a definition has been processed, or * <code>false</code> otherwise. * This method is deprecated; the method without the * <code>contextRelative</code> parameter should be used instead. * * @param definitionName Definition name to insert. * @param contextRelative Is the definition marked contextRelative ? * @param request Current page request. * @param response Current page response. * @return <code>true</code> if the method has processed uri as a * definition name, <code>false</code> otherwise. * @deprecated use processTilesDefinition(definitionName, request, response) * instead. This method will be removed in a version after 1.3.0. */ protected boolean processTilesDefinition(String definitionName, boolean contextRelative, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { return processTilesDefinition(definitionName, request, response); } /** * Process a Tile definition name. * This method tries to process the parameter <code>definitionName</code> * as a definition name. * It returns <code>true</code> if a definition has been processed, or * <code>false</code> otherwise. * * @param definitionName Definition name to insert. * @param request Current page request. * @param response Current page response. * @return <code>true</code> if the method has processed uri as a * definition name, <code>false</code> otherwise. */ protected boolean processTilesDefinition(String definitionName, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { // Do we do a forward (original behavior) or an include ? boolean doInclude = false; // Controller associated to a definition, if any Controller controller = null; // Computed uri to include String uri = null; ComponentContext tileContext = null; try { // Get current tile context if any. // If context exist, we will do an include tileContext = ComponentContext.getContext(request); doInclude = (tileContext != null); ComponentDefinition definition = null; // Process tiles definition names only if a definition factory exist, // and definition is found. if (definitionsFactory != null) { // Get definition of tiles/component corresponding to uri. try { definition = definitionsFactory.getDefinition(definitionName, request, getServletContext()); } catch (NoSuchDefinitionException ex) { // Ignore not found log.debug("NoSuchDefinitionException " + ex.getMessage()); } if (definition != null) { // We have a definition. // We use it to complete missing attribute in context. // We also get uri, controller. uri = definition.getPath(); controller = definition.getOrCreateController(); if (tileContext == null) { tileContext = new ComponentContext(definition.getAttributes()); ComponentContext.setContext(tileContext, request); } else { tileContext.addMissing(definition.getAttributes()); } } } // Process definition set in Action, if any. definition = DefinitionsUtil.getActionDefinition(request); if (definition != null) { // We have a definition. // We use it to complete missing attribute in context. // We also overload uri and controller if set in definition. if (definition.getPath() != null) { uri = definition.getPath(); } if (definition.getOrCreateController() != null) { controller = definition.getOrCreateController(); } if (tileContext == null) { tileContext = new ComponentContext(definition.getAttributes()); ComponentContext.setContext(tileContext, request); } else { tileContext.addMissing(definition.getAttributes()); } } } catch (java.lang.InstantiationException ex) { log.error("Can't create associated controller", ex); throw new ServletException("Can't create associated controller", ex); } catch (DefinitionsFactoryException ex) { throw new ServletException(ex); } // Have we found a definition ? if (uri == null) { return false; } // Execute controller associated to definition, if any. if (controller != null) { try { controller.execute(tileContext, request, response, getServletContext()); } catch (Exception e) { throw new ServletException(e); } } // If request comes from a previous Tile, do an include. // This allows to insert an action in a Tile. if (log.isDebugEnabled()) { log.debug("uri=" + uri + " doInclude=" + doInclude); } if (doInclude) { doInclude(uri, request, response); } else { doForward(uri, request, response); // original behavior } return true; } /** * Do a forward using request dispatcher. * Uri is a valid uri. If response has already been commited, do an include * instead. * @param uri Uri or Definition name to forward. * @param request Current page request. * @param response Current page response. */ protected void doForward(String uri, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { if (response.isCommitted()) { this.doInclude(uri, request, response); } else { super.doForward(uri, request, response); } } /** * Overloaded method from Struts' RequestProcessor. * Forward or redirect to the specified destination by the specified * mechanism. * This method catches the Struts' actionForward call. It checks if the * actionForward is done on a Tiles definition name. If true, process the * definition and insert it. If false, call the original parent's method. * @param request The servlet request we are processing. * @param response The servlet response we are creating. * @param forward The ActionForward controlling where we go next. * * @exception IOException if an input/output error occurs. * @exception ServletException if a servlet exception occurs. */ protected void processForwardConfig(HttpServletRequest request, HttpServletResponse response, ForwardConfig forward) throws IOException, ServletException { // Required by struts contract if (forward == null) { return; } if (log.isDebugEnabled()) { log.debug("processForwardConfig(" + forward.getPath() + ")"); } // Try to process the definition. if (processTilesDefinition(forward.getPath(), request, response)) { if (log.isDebugEnabled()) { log.debug(" '" + forward.getPath() + "' - processed as definition"); } return; } if (log.isDebugEnabled()) { log.debug(" '" + forward.getPath() + "' - processed as uri"); } // forward doesn't contain a definition, let parent do processing super.processForwardConfig(request, response, forward); } /** * Catch the call to a module relative forward. * If the specified uri is a tiles definition name, insert it. * Otherwise, parent processing is called. * Do a module relative forward to specified uri using request dispatcher. * Uri is relative to the current module. The real uri is computed by * prefixing the module name. * <strong>This method is used internally and is not part of the public * API. It is advised to not use it in subclasses.</strong> * @param uri Module-relative URI to forward to. * @param request Current page request. * @param response Current page response. * @since Struts 1.1 */ protected void internalModuleRelativeForward(String uri, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { if (processTilesDefinition(uri, request, response)) { return; } super.internalModuleRelativeForward(uri, request, response); } /** * Do a module relative include to specified uri using request dispatcher. * Uri is relative to the current module. The real uri is computed by * prefixing the module name. * <strong>This method is used internally and is not part of the public * API. It is advised to not use it in subclasses.</strong> * @param uri Module-relative URI to forward to. * @param request Current page request. * @param response Current page response. * @since Struts 1.1 */ protected void internalModuleRelativeInclude(String uri, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException { if (processTilesDefinition(uri, request, response)) { return; } super.internalModuleRelativeInclude(uri, request, response); } /** * Get associated definition factory. */ public DefinitionsFactory getDefinitionsFactory() { return definitionsFactory; } }