1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 package org.apache.tiles.servlet.context;
22
23 import java.io.IOException;
24 import java.util.Locale;
25 import java.util.Map;
26
27 import javax.servlet.RequestDispatcher;
28 import javax.servlet.ServletContext;
29 import javax.servlet.ServletException;
30 import javax.servlet.http.HttpServletRequest;
31 import javax.servlet.http.HttpServletResponse;
32
33 import org.apache.tiles.context.TilesRequestContext;
34 import org.apache.tiles.util.TilesIOException;
35
36 /***
37 * Servlet-based implementation of the TilesApplicationContext interface.
38 *
39 * @version $Rev: 632818 $ $Date: 2008-03-02 20:48:05 +0100 (Sun, 02 Mar 2008) $
40 */
41 public class ServletTilesRequestContext extends ServletTilesApplicationContext implements TilesRequestContext {
42
43 /***
44 * The request object to use.
45 */
46 private HttpServletRequest request;
47
48 /***
49 * The response object to use.
50 */
51 private HttpServletResponse response;
52
53
54 /***
55 * <p>The lazily instantiated <code>Map</code> of header name-value
56 * combinations (immutable).</p>
57 */
58 private Map<String, String> header = null;
59
60
61 /***
62 * <p>The lazily instantitated <code>Map</code> of header name-values
63 * combinations (immutable).</p>
64 */
65 private Map<String, String[]> headerValues = null;
66
67
68 /***
69 * <p>The lazily instantiated <code>Map</code> of request
70 * parameter name-value.</p>
71 */
72 private Map<String, String> param = null;
73
74
75 /***
76 * <p>The lazily instantiated <code>Map</code> of request
77 * parameter name-values.</p>
78 */
79 private Map<String, String[]> paramValues = null;
80
81 /***
82 * <p>The lazily instantiated <code>Map</code> of request scope
83 * attributes.</p>
84 */
85 private Map<String, Object> requestScope = null;
86
87 /***
88 * <p>The lazily instantiated <code>Map</code> of session scope
89 * attributes.</p>
90 */
91 private Map<String, Object> sessionScope = null;
92
93
94 /***
95 * Creates a new instance of ServletTilesRequestContext.
96 *
97 * @param servletContext The servlet context.
98 * @param request The request object.
99 * @param response The response object.
100 */
101 public ServletTilesRequestContext(ServletContext servletContext,
102 HttpServletRequest request,
103 HttpServletResponse response) {
104 super(servletContext);
105 initialize(request, response);
106 }
107
108
109 /*** {@inheritDoc} */
110 public Map<String, String> getHeader() {
111
112 if ((header == null) && (request != null)) {
113 header = new ServletHeaderMap(request);
114 }
115 return (header);
116
117 }
118
119
120 /*** {@inheritDoc} */
121 public Map<String, String[]> getHeaderValues() {
122
123 if ((headerValues == null) && (request != null)) {
124 headerValues = new ServletHeaderValuesMap(request);
125 }
126 return (headerValues);
127
128 }
129
130
131 /*** {@inheritDoc} */
132 public Map<String, String> getParam() {
133
134 if ((param == null) && (request != null)) {
135 param = new ServletParamMap(request);
136 }
137 return (param);
138
139 }
140
141
142 /*** {@inheritDoc} */
143 public Map<String, String[]> getParamValues() {
144
145 if ((paramValues == null) && (request != null)) {
146 paramValues = new ServletParamValuesMap(request);
147 }
148 return (paramValues);
149
150 }
151
152
153 /*** {@inheritDoc} */
154 public Map<String, Object> getRequestScope() {
155
156 if ((requestScope == null) && (request != null)) {
157 requestScope = new ServletRequestScopeMap(request);
158 }
159 return (requestScope);
160
161 }
162
163
164 /*** {@inheritDoc} */
165 public Map<String, Object> getSessionScope() {
166
167 if ((sessionScope == null) && (request != null)) {
168 sessionScope = new ServletSessionScopeMap(request);
169 }
170 return (sessionScope);
171
172 }
173
174 /*** {@inheritDoc} */
175 public void dispatch(String path) throws IOException {
176 if (response.isCommitted() || ServletUtil.isForceInclude(request)) {
177 include(path);
178 } else {
179 forward(path);
180 }
181 }
182
183 /***
184 * Forwards to a path.
185 *
186 * @param path The path to forward to.
187 * @throws IOException If something goes wrong during the operation.
188 */
189 protected void forward(String path) throws IOException {
190 RequestDispatcher rd = request.getRequestDispatcher(path);
191
192 if (rd == null) {
193 throw new IOException("No request dispatcher returned for path '"
194 + path + "'");
195 }
196
197 try {
198 rd.forward(request, response);
199 } catch (ServletException ex) {
200 throw wrapServletException(ex, "ServletException including path '"
201 + path + "'.");
202 }
203 }
204
205
206 /*** {@inheritDoc} */
207 public void include(String path) throws IOException {
208 ServletUtil.setForceInclude(request, true);
209 RequestDispatcher rd = request.getRequestDispatcher(path);
210
211 if (rd == null) {
212 throw new IOException("No request dispatcher returned for path '"
213 + path + "'");
214 }
215
216 try {
217 rd.include(request, response);
218 } catch (ServletException ex) {
219 throw wrapServletException(ex, "ServletException including path '"
220 + path + "'.");
221 }
222 }
223
224 /*** {@inheritDoc} */
225 public Locale getRequestLocale() {
226 return request.getLocale();
227 }
228
229 /*** {@inheritDoc} */
230 public HttpServletRequest getRequest() {
231 return request;
232 }
233
234 /*** {@inheritDoc} */
235 public HttpServletResponse getResponse() {
236 return response;
237 }
238
239 /***
240 * <p>Initialize (or reinitialize) this {@link ServletTilesRequestContext} instance
241 * for the specified Servlet API objects.</p>
242 *
243 * @param request The <code>HttpServletRequest</code> for this request
244 * @param response The <code>HttpServletResponse</code> for this request
245 */
246 public void initialize(HttpServletRequest request,
247 HttpServletResponse response) {
248
249
250 this.request = request;
251 this.response = response;
252
253 }
254
255
256 /***
257 * <p>Release references to allocated resources acquired in
258 * <code>initialize()</code> of via subsequent processing. After this
259 * method is called, subsequent calls to any other method than
260 * <code>initialize()</code> will return undefined results.</p>
261 */
262 public void release() {
263
264 header = null;
265 headerValues = null;
266 param = null;
267 paramValues = null;
268 requestScope = null;
269 sessionScope = null;
270
271
272 request = null;
273 response = null;
274 super.release();
275
276 }
277
278
279 /*** {@inheritDoc} */
280 public boolean isUserInRole(String role) {
281 return request.isUserInRole(role);
282 }
283
284 /***
285 * Wraps a ServletException to create an IOException with the root cause if present.
286 *
287 * @param ex The exception to wrap.
288 * @param message The message of the exception.
289 * @return The wrapped exception.
290 * @since 2.0.6
291 */
292 protected IOException wrapServletException(ServletException ex, String message) {
293 IOException retValue;
294 Throwable rootCause = ex.getRootCause();
295 if (rootCause != null) {
296
297
298 retValue = new TilesIOException(message, rootCause);
299 } else {
300 retValue = new TilesIOException(message, ex);
301 }
302
303 return retValue;
304 }
305 }