TilesRequestProcessor


1   /*
2    * $Id: TilesRequestProcessor.java 164703 2005-04-26 01:28:13Z niallp $ 
3    *
4    * Copyright 1999-2005 The Apache Software Foundation.
5    * 
6    * Licensed under the Apache License, Version 2.0 (the "License");
7    * you may not use this file except in compliance with the License.
8    * You may obtain a copy of the License at
9    * 
10   *      http://www.apache.org/licenses/LICENSE-2.0
11   * 
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  
19  package org.apache.struts.tiles;
20  
21  import java.io.IOException  ;
22  
23  import javax.servlet.ServletException  ;
24  import javax.servlet.http.HttpServletRequest  ;
25  import javax.servlet.http.HttpServletResponse  ;
26  
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.config.ForwardConfig;
32  import org.apache.struts.config.ModuleConfig;
33  
34  /**
35   * <p><strong>RequestProcessor</strong> contains the processing logic that
36   * the Struts controller servlet performs as it receives each servlet request
37   * from the container.</p>
38   * <p>This processor subclasses the Struts RequestProcessor in order to intercept calls to forward
39   * or include. When such calls are done, the Tiles processor checks if the specified URI
40   * is a definition name. If true, the definition is retrieved and included. If
41   * false, the original URI is included or a forward is performed.
42   * <p>
43   * Actually, catching is done by overloading the following methods:
44   * <ul>
45   * <li>{@link #processForwardConfig(HttpServletRequest,HttpServletResponse,ForwardConfig)}</li>
46   * <li>{@link #internalModuleRelativeForward(String, HttpServletRequest , HttpServletResponse)}</li>
47   * <li>{@link #internalModuleRelativeInclude(String, HttpServletRequest , HttpServletResponse)}</li>
48   * </ul>
49   * </p>
50   * @since Struts 1.1
51   */
52  public class TilesRequestProcessor extends RequestProcessor {
53  
54      /** 
55       * Definitions factory. 
56       */
57      protected DefinitionsFactory definitionsFactory = null;
58  
59      /**
60       * Commons Logging instance.
61       */
62      protected static Log log = LogFactory.getLog(TilesRequestProcessor.class);
63  
64      /**
65       * Initialize this request processor instance.
66       *
67       * @param servlet The ActionServlet we are associated with.
68       * @param moduleConfig The ModuleConfig we are associated with.
69       * @throws ServletException If an error occurs during initialization.
70       */
71      public void init(ActionServlet servlet, ModuleConfig moduleConfig)
72          throws ServletException   {
73  
74          super.init(servlet, moduleConfig);
75          this.initDefinitionsMapping();
76      }
77  
78      /**
79       * Read component instance mapping configuration file.
80       * This is where we read files properties.
81       */
82      protected void initDefinitionsMapping() throws ServletException   {
83          // Retrieve and set factory for this modules
84          definitionsFactory =
85              (
86                  (TilesUtilStrutsImpl) TilesUtil
87                      .getTilesUtil())
88                      .getDefinitionsFactory(
89                  getServletContext(),
90                  moduleConfig);
91  
92          if (definitionsFactory == null) { // problem !
93  
94              log.info(
95                  "Definition Factory not found for module '"
96                      + moduleConfig.getPrefix()
97                      + "'. "
98                      + "Have you declared the appropriate plugin in struts-config.xml ?");
99  
100             return;
101         }
102 
103         log.info(
104             "Tiles definition factory found for request processor '"
105                 + moduleConfig.getPrefix()
106                 + "'.");
107 
108     }
109 
110     /**
111      * Process a Tile definition name.
112      * This method tries to process the parameter <code>definitionName</code> as a definition name.
113      * It returns <code>true</code> if a definition has been processed, or <code>false</code> otherwise.
114      * Parameter <code>contextRelative</code> is not used in this implementation.
115      *
116      * @param definitionName Definition name to insert.
117      * @param contextRelative Is the definition marked contextRelative ?
118      * @param request Current page request.
119      * @param response Current page response.
120      * @return <code>true</code> if the method has processed uri as a definition name, <code>false</code> otherwise.
121      */
122     protected boolean processTilesDefinition(
123         String   definitionName,
124         boolean contextRelative,
125         HttpServletRequest   request,
126         HttpServletResponse   response)
127         throws IOException  , ServletException   {
128 
129         // Do we do a forward (original behavior) or an include ?
130         boolean doInclude = false;
131 
132         // Controller associated to a definition, if any
133         Controller controller = null;
134 
135         // Computed uri to include
136         String   uri = null;
137 
138         ComponentContext tileContext = null;
139 
140         try {
141             // Get current tile context if any.
142             // If context exist, we will do an include
143             tileContext = ComponentContext.getContext(request);
144             doInclude = (tileContext != null);
145             ComponentDefinition definition = null;
146 
147             // Process tiles definition names only if a definition factory exist,
148             // and definition is found.
149             if (definitionsFactory != null) {
150                 // Get definition of tiles/component corresponding to uri.
151                 try {
152                     definition =
153                         definitionsFactory.getDefinition(
154                             definitionName,
155                             request,
156                             getServletContext());
157                 } catch (NoSuchDefinitionException ex) {
158                     // Ignore not found
159                     log.debug("NoSuchDefinitionException " + ex.getMessage());
160                 }
161                 if (definition != null) { // We have a definition.
162                     // We use it to complete missing attribute in context.
163                     // We also get uri, controller.
164                     uri = definition.getPath();
165                     controller = definition.getOrCreateController();
166 
167                     if (tileContext == null) {
168                         tileContext =
169                             new ComponentContext(definition.getAttributes());
170                         ComponentContext.setContext(tileContext, request);
171 
172                     } else {
173                         tileContext.addMissing(definition.getAttributes());
174                     }
175                 }
176             }
177 
178             // Process definition set in Action, if any.
179             definition = DefinitionsUtil.getActionDefinition(request);
180             if (definition != null) { // We have a definition.
181                 // We use it to complete missing attribute in context.
182                 // We also overload uri and controller if set in definition.
183                 if (definition.getPath() != null) {
184                     uri = definition.getPath();
185                 }
186 
187                 if (definition.getOrCreateController() != null) {
188                     controller = definition.getOrCreateController();
189                 }
190 
191                 if (tileContext == null) {
192                     tileContext =
193                         new ComponentContext(definition.getAttributes());
194                     ComponentContext.setContext(tileContext, request);
195                 } else {
196                     tileContext.addMissing(definition.getAttributes());
197                 }
198             }
199 
200         } catch (java.lang.InstantiationException   ex) {
201 
202             log.error("Can't create associated controller", ex);
203 
204             throw new ServletException  (
205                 "Can't create associated controller",
206                 ex);
207         } catch (DefinitionsFactoryException ex) {
208             throw new ServletException  (ex);
209         }
210 
211         // Have we found a definition ?
212         if (uri == null) {
213             return false;
214         }
215 
216         // Execute controller associated to definition, if any.
217         if (controller != null) {
218             try {
219                 controller.execute(
220                     tileContext,
221                     request,
222                     response,
223                     getServletContext());
224                     
225             } catch (Exception   e) {
226                 throw new ServletException  (e); 
227             }
228         }
229 
230         // If request comes from a previous Tile, do an include.
231         // This allows to insert an action in a Tile.
232         if (log.isDebugEnabled()) {
233             log.debug("uri=" + uri + " doInclude=" + doInclude);
234         }
235         
236         if (doInclude) {
237             doInclude(uri, request, response);
238         } else {
239             doForward(uri, request, response); // original behavior
240         }
241 
242         return true;
243     }
244 
245     /**
246      * Do a forward using request dispatcher.
247      * Uri is a valid uri. If response has already been commited, do an include
248      * instead.
249      * @param uri Uri or Definition name to forward.
250      * @param request Current page request.
251      * @param response Current page response.
252      */
253     protected void doForward(
254         String   uri,
255         HttpServletRequest   request,
256         HttpServletResponse   response)
257         throws IOException  , ServletException   {
258             
259         if (response.isCommitted()) {
260             this.doInclude(uri, request, response);
261             
262         } else {
263             super.doForward(uri, request, response);
264         }
265     }
266 
267     /**
268      * Overloaded method from Struts' RequestProcessor.
269      * Forward or redirect to the specified destination by the specified
270      * mechanism.
271      * This method catches the Struts' actionForward call. It checks if the
272      * actionForward is done on a Tiles definition name. If true, process the
273      * definition and insert it. If false, call the original parent's method.
274      * @param request The servlet request we are processing.
275      * @param response The servlet response we are creating.
276      * @param forward The ActionForward controlling where we go next.
277      *
278      * @exception IOException if an input/output error occurs.
279      * @exception ServletException if a servlet exception occurs.
280      */
281     protected void processForwardConfig(
282         HttpServletRequest   request,
283         HttpServletResponse   response,
284         ForwardConfig forward)
285         throws IOException  , ServletException   {
286             
287         // Required by struts contract
288         if (forward == null) {
289             return;
290         }
291 
292         if (log.isDebugEnabled()) {
293             log.debug(
294                 "processForwardConfig("
295                     + forward.getPath()
296                     + ", "
297                     + forward.getContextRelative()
298                     + ")");
299         }
300         
301         // Try to process the definition.
302         if (processTilesDefinition(forward.getPath(),
303             forward.getContextRelative(),
304             request,
305             response)) {
306             if (log.isDebugEnabled()) {
307                 log.debug(
308                     "  '" + forward.getPath() + "' - processed as definition");
309             }
310             return;
311         }
312         
313         if (log.isDebugEnabled()) {
314             log.debug("  '" + forward.getPath() + "' - processed as uri");
315         }
316         
317         // forward doesn't contain a definition, let parent do processing
318         super.processForwardConfig(request, response, forward);
319     }
320 
321     /**
322      * Catch the call to a module relative forward.
323      * If the specified uri is a tiles definition name, insert it.
324      * Otherwise, parent processing is called.
325      * Do a module relative forward to specified uri using request dispatcher.
326      * Uri is relative to the current module. The real uri is computed by 
327      * prefixing the module name.
328      * <strong>This method is used internally and is not part of the public 
329      * API. It is advised to not use it in subclasses.</strong>
330      * @param uri Module-relative URI to forward to.
331      * @param request Current page request.
332      * @param response Current page response.
333      * @since Struts 1.1
334      */
335     protected void internalModuleRelativeForward(
336         String   uri,
337         HttpServletRequest   request,
338         HttpServletResponse   response)
339         throws IOException  , ServletException   {
340             
341         if (processTilesDefinition(uri, false, request, response)) {
342             return;
343         }
344 
345         super.internalModuleRelativeForward(uri, request, response);
346     }
347 
348     /**
349      * Do a module relative include to specified uri using request dispatcher.
350      * Uri is relative to the current module. The real uri is computed by 
351      * prefixing the module name.
352      * <strong>This method is used internally and is not part of the public 
353      * API. It is advised to not use it in subclasses.</strong>
354      * @param uri Module-relative URI to forward to.
355      * @param request Current page request.
356      * @param response Current page response.
357      * @since Struts 1.1
358      */
359     protected void internalModuleRelativeInclude(
360         String   uri,
361         HttpServletRequest   request,
362         HttpServletResponse   response)
363         throws IOException  , ServletException   {
364             
365         if (processTilesDefinition(uri, false, request, response)) {
366             return;
367         }
368 
369         super.internalModuleRelativeInclude(uri, request, response);
370     }
371 
372     /**
373      * Get associated definition factory.
374      */
375     public DefinitionsFactory getDefinitionsFactory() {
376         return definitionsFactory;
377     }
378 
379 }
380
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags