KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > jasper > servlet > JspCServletContext


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 package org.apache.jasper.servlet;
19
20
21 import java.io.File JavaDoc;
22 import java.io.InputStream JavaDoc;
23 import java.io.PrintWriter JavaDoc;
24 import java.net.MalformedURLException JavaDoc;
25 import java.net.URL JavaDoc;
26 import java.util.Enumeration JavaDoc;
27 import java.util.HashSet JavaDoc;
28 import java.util.Hashtable JavaDoc;
29 import java.util.Set JavaDoc;
30 import java.util.Vector JavaDoc;
31
32 import javax.servlet.RequestDispatcher JavaDoc;
33 import javax.servlet.Servlet JavaDoc;
34 import javax.servlet.ServletContext JavaDoc;
35 import javax.servlet.ServletException JavaDoc;
36
37
38 /**
39  * Simple <code>ServletContext</code> implementation without
40  * HTTP-specific methods.
41  *
42  * @author Peter Rossbach (pr@webapp.de)
43  */
44
45 public class JspCServletContext implements ServletContext JavaDoc {
46
47
48     // ----------------------------------------------------- Instance Variables
49
50
51     /**
52      * Servlet context attributes.
53      */
54     protected Hashtable JavaDoc myAttributes;
55
56
57     /**
58      * The log writer we will write log messages to.
59      */
60     protected PrintWriter JavaDoc myLogWriter;
61
62
63     /**
64      * The base URL (document root) for this context.
65      */
66     protected URL JavaDoc myResourceBaseURL;
67
68
69     // ----------------------------------------------------------- Constructors
70
71
72     /**
73      * Create a new instance of this ServletContext implementation.
74      *
75      * @param aLogWriter PrintWriter which is used for <code>log()</code> calls
76      * @param aResourceBaseURL Resource base URL
77      */
78     public JspCServletContext(PrintWriter JavaDoc aLogWriter, URL JavaDoc aResourceBaseURL) {
79
80         myAttributes = new Hashtable JavaDoc();
81         myLogWriter = aLogWriter;
82         myResourceBaseURL = aResourceBaseURL;
83
84     }
85
86
87     // --------------------------------------------------------- Public Methods
88
89
90     /**
91      * Return the specified context attribute, if any.
92      *
93      * @param name Name of the requested attribute
94      */
95     public Object JavaDoc getAttribute(String JavaDoc name) {
96
97         return (myAttributes.get(name));
98
99     }
100
101
102     /**
103      * Return an enumeration of context attribute names.
104      */
105     public Enumeration JavaDoc getAttributeNames() {
106
107         return (myAttributes.keys());
108
109     }
110
111
112     /**
113      * Return the servlet context for the specified path.
114      *
115      * @param uripath Server-relative path starting with '/'
116      */
117     public ServletContext JavaDoc getContext(String JavaDoc uripath) {
118
119         return (null);
120
121     }
122
123
124     /**
125      * Return the context path.
126      */
127     public String JavaDoc getContextPath() {
128
129         return (null);
130
131     }
132
133
134     /**
135      * Return the specified context initialization parameter.
136      *
137      * @param name Name of the requested parameter
138      */
139     public String JavaDoc getInitParameter(String JavaDoc name) {
140
141         return (null);
142
143     }
144
145
146     /**
147      * Return an enumeration of the names of context initialization
148      * parameters.
149      */
150     public Enumeration JavaDoc getInitParameterNames() {
151
152         return (new Vector JavaDoc().elements());
153
154     }
155
156
157     /**
158      * Return the Servlet API major version number.
159      */
160     public int getMajorVersion() {
161
162         return (2);
163
164     }
165
166
167     /**
168      * Return the MIME type for the specified filename.
169      *
170      * @param file Filename whose MIME type is requested
171      */
172     public String JavaDoc getMimeType(String JavaDoc file) {
173
174         return (null);
175
176     }
177
178
179     /**
180      * Return the Servlet API minor version number.
181      */
182     public int getMinorVersion() {
183
184         return (3);
185
186     }
187
188
189     /**
190      * Return a request dispatcher for the specified servlet name.
191      *
192      * @param name Name of the requested servlet
193      */
194     public RequestDispatcher JavaDoc getNamedDispatcher(String JavaDoc name) {
195
196         return (null);
197
198     }
199
200
201     /**
202      * Return the real path for the specified context-relative
203      * virtual path.
204      *
205      * @param path The context-relative virtual path to resolve
206      */
207     public String JavaDoc getRealPath(String JavaDoc path) {
208
209         if (!myResourceBaseURL.getProtocol().equals("file"))
210             return (null);
211         if (!path.startsWith("/"))
212             return (null);
213         try {
214             return
215                 (getResource(path).getFile().replace('/', File.separatorChar));
216         } catch (Throwable JavaDoc t) {
217             return (null);
218         }
219
220     }
221             
222             
223     /**
224      * Return a request dispatcher for the specified context-relative path.
225      *
226      * @param path Context-relative path for which to acquire a dispatcher
227      */
228     public RequestDispatcher JavaDoc getRequestDispatcher(String JavaDoc path) {
229
230         return (null);
231
232     }
233
234
235     /**
236      * Return a URL object of a resource that is mapped to the
237      * specified context-relative path.
238      *
239      * @param path Context-relative path of the desired resource
240      *
241      * @exception MalformedURLException if the resource path is
242      * not properly formed
243      */
244     public URL JavaDoc getResource(String JavaDoc path) throws MalformedURLException JavaDoc {
245
246         if (!path.startsWith("/"))
247             throw new MalformedURLException JavaDoc("Path '" + path +
248                                             "' does not start with '/'");
249         URL JavaDoc url = new URL JavaDoc(myResourceBaseURL, path.substring(1));
250         InputStream JavaDoc is = null;
251         try {
252             is = url.openStream();
253         } catch (Throwable JavaDoc t) {
254             url = null;
255         } finally {
256             if (is != null) {
257                 try {
258                     is.close();
259                 } catch (Throwable JavaDoc t2) {
260                     // Ignore
261 }
262             }
263         }
264         return url;
265
266     }
267
268
269     /**
270      * Return an InputStream allowing access to the resource at the
271      * specified context-relative path.
272      *
273      * @param path Context-relative path of the desired resource
274      */
275     public InputStream JavaDoc getResourceAsStream(String JavaDoc path) {
276
277         try {
278             return (getResource(path).openStream());
279         } catch (Throwable JavaDoc t) {
280             return (null);
281         }
282
283     }
284
285
286     /**
287      * Return the set of resource paths for the "directory" at the
288      * specified context path.
289      *
290      * @param path Context-relative base path
291      */
292     public Set JavaDoc getResourcePaths(String JavaDoc path) {
293
294         Set JavaDoc thePaths = new HashSet JavaDoc();
295         if (!path.endsWith("/"))
296             path += "/";
297         String JavaDoc basePath = getRealPath(path);
298         if (basePath == null)
299             return (thePaths);
300         File JavaDoc theBaseDir = new File JavaDoc(basePath);
301         if (!theBaseDir.exists() || !theBaseDir.isDirectory())
302             return (thePaths);
303         String JavaDoc theFiles[] = theBaseDir.list();
304         for (int i = 0; i < theFiles.length; i++) {
305             File JavaDoc testFile = new File JavaDoc(basePath + File.separator + theFiles[i]);
306             if (testFile.isFile())
307                 thePaths.add(path + theFiles[i]);
308             else if (testFile.isDirectory())
309                 thePaths.add(path + theFiles[i] + "/");
310         }
311         return (thePaths);
312
313     }
314
315
316     /**
317      * Return descriptive information about this server.
318      */
319     public String JavaDoc getServerInfo() {
320
321         return ("JspCServletContext/1.0");
322
323     }
324
325
326     /**
327      * Return a null reference for the specified servlet name.
328      *
329      * @param name Name of the requested servlet
330      *
331      * @deprecated This method has been deprecated with no replacement
332      */
333     public Servlet JavaDoc getServlet(String JavaDoc name) throws ServletException JavaDoc {
334
335         return (null);
336
337     }
338
339
340     /**
341      * Return the name of this servlet context.
342      */
343     public String JavaDoc getServletContextName() {
344
345         return (getServerInfo());
346
347     }
348
349
350     /**
351      * Return an empty enumeration of servlet names.
352      *
353      * @deprecated This method has been deprecated with no replacement
354      */
355     public Enumeration JavaDoc getServletNames() {
356
357         return (new Vector JavaDoc().elements());
358
359     }
360
361
362     /**
363      * Return an empty enumeration of servlets.
364      *
365      * @deprecated This method has been deprecated with no replacement
366      */
367     public Enumeration JavaDoc getServlets() {
368
369         return (new Vector JavaDoc().elements());
370
371     }
372
373
374     /**
375      * Log the specified message.
376      *
377      * @param message The message to be logged
378      */
379     public void log(String JavaDoc message) {
380
381         myLogWriter.println(message);
382
383     }
384
385
386     /**
387      * Log the specified message and exception.
388      *
389      * @param exception The exception to be logged
390      * @param message The message to be logged
391      *
392      * @deprecated Use log(String,Throwable) instead
393      */
394     public void log(Exception JavaDoc exception, String JavaDoc message) {
395
396         log(message, exception);
397
398     }
399
400
401     /**
402      * Log the specified message and exception.
403      *
404      * @param message The message to be logged
405      * @param exception The exception to be logged
406      */
407     public void log(String JavaDoc message, Throwable JavaDoc exception) {
408
409         myLogWriter.println(message);
410         exception.printStackTrace(myLogWriter);
411
412     }
413
414
415     /**
416      * Remove the specified context attribute.
417      *
418      * @param name Name of the attribute to remove
419      */
420     public void removeAttribute(String JavaDoc name) {
421
422         myAttributes.remove(name);
423
424     }
425
426
427     /**
428      * Set or replace the specified context attribute.
429      *
430      * @param name Name of the context attribute to set
431      * @param value Corresponding attribute value
432      */
433     public void setAttribute(String JavaDoc name, Object JavaDoc value) {
434
435         myAttributes.put(name, value);
436
437     }
438
439
440
441 }
442
Popular Tags