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