Java > Open Source Codes > org > apache > jasper > JspCompilationContext


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;
19
20 import java.io.File ;
21 import java.io.FileNotFoundException ;
22 import java.net.MalformedURLException ;
23 import java.net.URL ;
24 import java.net.URLClassLoader ;
25 import java.util.HashMap ;
26 import java.util.Map ;
27 import java.util.Set ;
28
29 import javax.servlet.ServletContext ;
30 import javax.servlet.jsp.tagext.TagInfo ;
31
32 import org.apache.jasper.compiler.Compiler;
33 import org.apache.jasper.compiler.JspRuntimeContext;
34 import org.apache.jasper.compiler.JspUtil;
35 import org.apache.jasper.compiler.Localizer;
36 import org.apache.jasper.compiler.ServletWriter;
37 import org.apache.jasper.servlet.JasperLoader;
38 import org.apache.jasper.servlet.JspServletWrapper;
39
40 /**
41  * A place holder for various things that are used through out the JSP
42  * engine. This is a per-request/per-context data structure. Some of
43  * the instance variables are set at different points.
44  *
45  * Most of the path-related stuff is here - mangling names, versions, dirs,
46  * loading resources and dealing with uris.
47  *
48  * @author Anil K. Vijendran
49  * @author Harish Prabandham
50  * @author Pierre Delisle
51  * @author Costin Manolache
52  * @author Kin-man Chung
53  */
54 public class JspCompilationContext {
55
56     protected org.apache.commons.logging.Log log =
57         org.apache.commons.logging.LogFactory.getLog(JspCompilationContext.class);
58
59     protected Map <String , URL > tagFileJarUrls;
60     protected boolean isPackagedTagFile;
61
62     protected String className;
63     protected String jspUri;
64     protected boolean isErrPage;
65     protected String basePackageName;
66     protected String derivedPackageName;
67     protected String servletJavaFileName;
68     protected String javaPath;
69     protected String classFileName;
70     protected String contentType;
71     protected ServletWriter writer;
72     protected Options options;
73     protected JspServletWrapper jsw;
74     protected Compiler jspCompiler;
75     protected String classPath;
76
77     protected String baseURI;
78     protected String outputDir;
79     protected ServletContext context;
80     protected URLClassLoader loader;
81
82     protected JspRuntimeContext rctxt;
83
84     protected int removed = 0;
85
86     protected URLClassLoader jspLoader;
87     protected URL baseUrl;
88     protected Class servletClass;
89
90     protected boolean isTagFile;
91     protected boolean protoTypeMode;
92     protected TagInfo tagInfo;
93     protected URL tagFileJarUrl;
94
95     // jspURI _must_ be relative to the context
96 public JspCompilationContext(String jspUri,
97                                  boolean isErrPage,
98                                  Options options,
99                                  ServletContext context,
100                                  JspServletWrapper jsw,
101                                  JspRuntimeContext rctxt) {
102
103         this.jspUri = canonicalURI(jspUri);
104         this.isErrPage = isErrPage;
105         this.options = options;
106         this.jsw = jsw;
107         this.context = context;
108
109         this.baseURI = jspUri.substring(0, jspUri.lastIndexOf('/') + 1);
110         // hack fix for resolveRelativeURI
111 if (baseURI == null) {
112             baseURI = "/";
113         } else if (baseURI.charAt(0) != '/') {
114             // strip the basde slash since it will be combined with the
115 // uriBase to generate a file
116 baseURI = "/" + baseURI;
117         }
118         if (baseURI.charAt(baseURI.length() - 1) != '/') {
119             baseURI += '/';
120         }
121
122         this.rctxt = rctxt;
123         this.tagFileJarUrls = new HashMap <String , URL >();
124         this.basePackageName = Constants.JSP_PACKAGE_NAME;
125     }
126
127     public JspCompilationContext(String tagfile,
128                                  TagInfo tagInfo,
129                                  Options options,
130                                  ServletContext context,
131                                  JspServletWrapper jsw,
132                                  JspRuntimeContext rctxt,
133                                  URL tagFileJarUrl) {
134         this(tagfile, false, options, context, jsw, rctxt);
135         this.isTagFile = true;
136         this.tagInfo = tagInfo;
137         this.tagFileJarUrl = tagFileJarUrl;
138         if (tagFileJarUrl != null) {
139             isPackagedTagFile = true;
140         }
141     }
142
143     /* ==================== Methods to override ==================== */
144     
145     /** ---------- Class path and loader ---------- */
146
147     /**
148      * The classpath that is passed off to the Java compiler.
149      */
150     public String getClassPath() {
151         if( classPath != null )
152             return classPath;
153         return rctxt.getClassPath();
154     }
155
156     /**
157      * The classpath that is passed off to the Java compiler.
158      */
159     public void setClassPath(String classPath) {
160         this.classPath = classPath;
161     }
162
163     /**
164      * What class loader to use for loading classes while compiling
165      * this JSP?
166      */
167     public ClassLoader getClassLoader() {
168         if( loader != null )
169             return loader;
170         return rctxt.getParentClassLoader();
171     }
172
173     public void setClassLoader(URLClassLoader loader) {
174         this.loader = loader;
175     }
176
177     public ClassLoader getJspLoader() {
178         if( jspLoader == null ) {
179             jspLoader = new JasperLoader
180             (new URL [] {baseUrl},
181                     getClassLoader(),
182                     rctxt.getPermissionCollection(),
183                     rctxt.getCodeSource());
184         }
185         return jspLoader;
186     }
187
188     /** ---------- Input/Output ---------- */
189     
190     /**
191      * The output directory to generate code into. The output directory
192      * is make up of the scratch directory, which is provide in Options,
193      * plus the directory derived from the package name.
194      */
195     public String getOutputDir() {
196     if (outputDir == null) {
197         createOutputDir();
198     }
199
200         return outputDir;
201     }
202
203     /**
204      * Create a "Compiler" object based on some init param data. This
205      * is not done yet. Right now we're just hardcoding the actual
206      * compilers that are created.
207      */
208     public Compiler createCompiler() throws JasperException {
209         if (jspCompiler != null ) {
210             return jspCompiler;
211         }
212         jspCompiler = null;
213         if (options.getCompilerClassName() != null) {
214             jspCompiler = createCompiler(options.getCompilerClassName());
215         } else {
216             if (options.getCompiler() == null) {
217                 jspCompiler = createCompiler("org.apache.jasper.compiler.JDTCompiler");
218                 if (jspCompiler == null) {
219                     jspCompiler = createCompiler("org.apache.jasper.compiler.AntCompiler");
220                 }
221             } else {
222                 jspCompiler = createCompiler("org.apache.jasper.compiler.AntCompiler");
223                 if (jspCompiler == null) {
224                     jspCompiler = createCompiler("org.apache.jasper.compiler.JDTCompiler");
225                 }
226             }
227         }
228         if (jspCompiler == null) {
229             throw new IllegalStateException (Localizer.getMessage("jsp.error.compiler"));
230         }
231         jspCompiler.init(this, jsw);
232         return jspCompiler;
233     }
234
235     protected Compiler createCompiler(String className) {
236         Compiler compiler = null;
237         try {
238             compiler = (Compiler ) Class.forName(className).newInstance();
239         } catch (InstantiationException e) {
240             log.warn(Localizer.getMessage("jsp.error.compiler"), e);
241         } catch (IllegalAccessException e) {
242             log.warn(Localizer.getMessage("jsp.error.compiler"), e);
243         } catch (NoClassDefFoundError e) {
244             if (log.isDebugEnabled()) {
245                 log.debug(Localizer.getMessage("jsp.error.compiler"), e);
246             }
247         } catch (ClassNotFoundException e) {
248             if (log.isDebugEnabled()) {
249                 log.debug(Localizer.getMessage("jsp.error.compiler"), e);
250             }
251         }
252         return compiler;
253     }
254     
255     public Compiler getCompiler() {
256         return jspCompiler;
257     }
258
259     /** ---------- Access resources in the webapp ---------- */
260
261     /**
262      * Get the full value of a URI relative to this compilations context
263      * uses current file as the base.
264      */
265     public String resolveRelativeUri(String uri) {
266         // sometimes we get uri's massaged from File(String), so check for
267 // a root directory deperator char
268 if (uri.startsWith("/") || uri.startsWith(File.separator)) {
269             return uri;
270         } else {
271             return baseURI + uri;
272         }
273     }
274
275     /**
276      * Gets a resource as a stream, relative to the meanings of this
277      * context's implementation.
278      * @return a null if the resource cannot be found or represented
279      * as an InputStream.
280      */
281     public java.io.InputStream getResourceAsStream(String res) {
282         return context.getResourceAsStream(canonicalURI(res));
283     }
284
285
286     public URL getResource(String res) throws MalformedURLException {
287         return context.getResource(canonicalURI(res));
288     }
289
290     public Set getResourcePaths(String path) {
291         return context.getResourcePaths(canonicalURI(path));
292     }
293
294     /**
295      * Gets the actual path of a URI relative to the context of
296      * the compilation.
297      */
298     public String getRealPath(String path) {
299         if (context != null) {
300             return context.getRealPath(path);
301         }
302         return path;
303     }
304
305     /**
306      * Returns the tag-file-name-to-JAR-file map of this compilation unit,
307      * which maps tag file names to the JAR files in which the tag files are
308      * packaged.
309      *
310      * The map is populated when parsing the tag-file elements of the TLDs
311      * of any imported taglibs.
312      */
313     public URL getTagFileJarUrl(String tagFile) {
314         return this.tagFileJarUrls.get(tagFile);
315     }
316
317     public void setTagFileJarUrl(String tagFile, URL tagFileURL) {
318         this.tagFileJarUrls.put(tagFile, tagFileURL);
319     }
320
321     /**
322      * Returns the JAR file in which the tag file for which this
323      * JspCompilationContext was created is packaged, or null if this
324      * JspCompilationContext does not correspond to a tag file, or if the
325      * corresponding tag file is not packaged in a JAR.
326      */
327     public URL getTagFileJarUrl() {
328         return this.tagFileJarUrl;
329     }
330
331     /* ==================== Common implementation ==================== */
332
333     /**
334      * Just the class name (does not include package name) of the
335      * generated class.
336      */
337     public String getServletClassName() {
338
339         if (className != null) {
340             return className;
341         }
342
343         if (isTagFile) {
344             className = tagInfo.getTagClassName();
345             int lastIndex = className.lastIndexOf('.');
346             if (lastIndex != -1) {
347                 className = className.substring(lastIndex + 1);
348             }
349         } else {
350             int iSep = jspUri.lastIndexOf('/') + 1;
351             className = JspUtil.makeJavaIdentifier(jspUri.substring(iSep));
352         }
353         return className;
354     }
355
356     public void setServletClassName(String className) {
357         this.className = className;
358     }
359     
360     /**
361      * Path of the JSP URI. Note that this is not a file name. This is
362      * the context rooted URI of the JSP file.
363      */
364     public String getJspFile() {
365         return jspUri;
366     }
367
368     /**
369      * Are we processing something that has been declared as an
370      * errorpage?
371      */
372     public boolean isErrorPage() {
373         return isErrPage;
374     }
375
376     public void setErrorPage(boolean isErrPage) {
377         this.isErrPage = isErrPage;
378     }
379
380     public boolean isTagFile() {
381         return isTagFile;
382     }
383
384     public TagInfo getTagInfo() {
385         return tagInfo;
386     }
387
388     public void setTagInfo(TagInfo tagi) {
389         tagInfo = tagi;
390     }
391
392     /**
393      * True if we are compiling a tag file in prototype mode.
394      * ie we only generate codes with class for the tag handler with empty
395      * method bodies.
396      */
397     public boolean isPrototypeMode() {
398         return protoTypeMode;
399     }
400
401     public void setPrototypeMode(boolean pm) {
402         protoTypeMode = pm;
403     }
404
405     /**
406      * Package name for the generated class is make up of the base package
407      * name, which is user settable, and the derived package name. The
408      * derived package name directly mirrors the file heirachy of the JSP page.
409      */
410     public String getServletPackageName() {
411         if (isTagFile()) {
412             String className = tagInfo.getTagClassName();
413             int lastIndex = className.lastIndexOf('.');
414             String pkgName = "";
415             if (lastIndex != -1) {
416                 pkgName = className.substring(0, lastIndex);
417             }
418             return pkgName;
419         } else {
420             String dPackageName = getDerivedPackageName();
421             if (dPackageName.length() == 0) {
422                 return basePackageName;
423             }
424             return basePackageName + '.' + getDerivedPackageName();
425         }
426     }
427
428     protected String getDerivedPackageName() {
429         if (derivedPackageName == null) {
430             int iSep = jspUri.lastIndexOf('/');
431             derivedPackageName = (iSep > 0) ?
432                     JspUtil.makeJavaPackage(jspUri.substring(1,iSep)) : "";
433         }
434         return derivedPackageName;
435     }
436         
437     /**
438      * The package name into which the servlet class is generated.
439      */
440     public void setServletPackageName(String servletPackageName) {
441         this.basePackageName = servletPackageName;
442     }
443
444     /**
445      * Full path name of the Java file into which the servlet is being
446      * generated.
447      */
448     public String getServletJavaFileName() {
449         if (servletJavaFileName == null) {
450             servletJavaFileName = getOutputDir() + getServletClassName() + ".java";
451         }
452         return servletJavaFileName;
453     }
454
455     /**
456      * Get hold of the Options object for this context.
457      */
458     public Options getOptions() {
459         return options;
460     }
461
462     public ServletContext getServletContext() {
463         return context;
464     }
465
466     public JspRuntimeContext getRuntimeContext() {
467         return rctxt;
468     }
469
470     /**
471      * Path of the Java file relative to the work directory.
472      */
473     public String getJavaPath() {
474
475         if (javaPath != null) {
476             return javaPath;
477         }
478
479         if (isTagFile()) {
480         String tagName = tagInfo.getTagClassName();
481             javaPath = tagName.replace('.', '/') + ".java";
482         } else {
483             javaPath = getServletPackageName().replace('.', '/') + '/' +
484                        getServletClassName() + ".java";
485     }
486         return javaPath;
487     }
488
489     public String getClassFileName() {
490         if (classFileName == null) {
491             classFileName = getOutputDir() + getServletClassName() + ".class";
492         }
493         return classFileName;
494     }
495
496     /**
497      * Get the content type of this JSP.
498      *
499      * Content type includes content type and encoding.
500      */
501     public String getContentType() {
502         return contentType;
503     }
504
505     public void setContentType(String contentType) {
506         this.contentType = contentType;
507     }
508
509     /**
510      * Where is the servlet being generated?
511      */
512     public ServletWriter getWriter() {
513         return writer;
514     }
515
516     public void setWriter(ServletWriter writer) {
517         this.writer = writer;
518     }
519
520     /**
521      * Gets the 'location' of the TLD associated with the given taglib 'uri'.
522      *
523      * @return An array of two Strings: The first element denotes the real
524      * path to the TLD. If the path to the TLD points to a jar file, then the
525      * second element denotes the name of the TLD entry in the jar file.
526      * Returns null if the given uri is not associated with any tag library
527      * 'exposed' in the web application.
528      */
529     public String [] getTldLocation(String uri) throws JasperException {
530         String [] location =
531             getOptions().getTldLocationsCache().getLocation(uri);
532         return location;
533     }
534
535     /**
536      * Are we keeping generated code around?
537      */
538     public boolean keepGenerated() {
539         return getOptions().getKeepGenerated();
540     }
541
542     // ==================== Removal ====================
543
544     public void incrementRemoved() {
545         if (removed == 0 && rctxt != null) {
546             rctxt.removeWrapper(jspUri);
547         }
548         removed++;
549     }
550
551     public boolean isRemoved() {
552         if (removed > 1 ) {
553             return true;
554         }
555         return false;
556     }
557
558     // ==================== Compile and reload ====================
559
560     public void compile() throws JasperException, FileNotFoundException {
561         createCompiler();
562         if (isPackagedTagFile || jspCompiler.isOutDated()) {
563             try {
564                 jspCompiler.removeGeneratedFiles();
565                 jspLoader = null;
566                 jspCompiler.compile();
567                 jsw.setReload(true);
568                 jsw.setCompilationException(null);
569             } catch (JasperException ex) {
570                 // Cache compilation exception
571 jsw.setCompilationException(ex);
572                 throw ex;
573             } catch (Exception ex) {
574                 JasperException je = new JasperException(
575                             Localizer.getMessage("jsp.error.unable.compile"),
576                             ex);
577                 // Cache compilation exception
578 jsw.setCompilationException(je);
579                 throw je;
580             }
581         }
582     }
583
584     // ==================== Manipulating the class ====================
585
586     public Class load()
587         throws JasperException, FileNotFoundException
588     {
589         try {
590             getJspLoader();
591             
592             String name;
593             if (isTagFile()) {
594                 name = tagInfo.getTagClassName();
595             } else {
596                 name = getServletPackageName() + "." + getServletClassName();
597             }
598             servletClass = jspLoader.loadClass(name);
599         } catch (ClassNotFoundException cex) {
600             throw new JasperException(Localizer.getMessage("jsp.error.unable.load"),
601                                       cex);
602         } catch (Exception ex) {
603             throw new JasperException(Localizer.getMessage("jsp.error.unable.compile"),
604                                       ex);
605         }
606         removed = 0;
607         return servletClass;
608     }
609
610     // ==================== protected methods ====================
611
612     static Object outputDirLock = new Object ();
613
614     public void checkOutputDir() {
615         if (outputDir != null) {
616             if (!(new File (outputDir)).exists()) {
617                 makeOutputDir();
618             }
619         } else {
620             createOutputDir();
621         }
622     }
623         
624     protected boolean makeOutputDir() {
625         synchronized(outputDirLock) {
626             File outDirFile = new File (outputDir);
627             return (outDirFile.exists() || outDirFile.mkdirs());
628         }
629     }
630
631     protected void createOutputDir() {
632         String path = null;
633         if (isTagFile()) {
634         String tagName = tagInfo.getTagClassName();
635             path = tagName.replace('.', '/');
636         path = path.substring(0, path.lastIndexOf('/'));
637         } else {
638             path = getServletPackageName().replace('.', '/');
639     }
640
641             // Append servlet or tag handler path to scratch dir
642 try {
643                 baseUrl = options.getScratchDir().toURL();
644                 String outUrlString = baseUrl.toString() + '/' + path;
645                 URL outUrl = new URL (outUrlString);
646                 outputDir = outUrl.getFile() + File.separator;
647                 if (!makeOutputDir()) {
648                     throw new IllegalStateException (Localizer.getMessage("jsp.error.outputfolder"));
649                 }
650             } catch (MalformedURLException e) {
651                 throw new IllegalStateException (Localizer.getMessage("jsp.error.outputfolder"), e);
652             }
653     }
654     
655     protected static final boolean isPathSeparator(char c) {
656        return (c == '/' || c == '\\');
657     }
658
659     protected static final String canonicalURI(String s) {
660        if (s == null) return null;
661        StringBuffer result = new StringBuffer ();
662        final int len = s.length();
663        int pos = 0;
664        while (pos < len) {
665            char c = s.charAt(pos);
666            if ( isPathSeparator(c) ) {
667                /*
668                 * multiple path separators.
669                 * 'foo///bar' -> 'foo/bar'
670                 */
671                while (pos+1 < len && isPathSeparator(s.charAt(pos+1))) {
672                    ++pos;
673                }
674
675                if (pos+1 < len && s.charAt(pos+1) == '.') {
676                    /*
677                     * a single dot at the end of the path - we are done.
678                     */
679                    if (pos+2 >= len) break;
680
681                    switch (s.charAt(pos+2)) {
682                        /*
683                         * self directory in path
684                         * foo/./bar -> foo/bar
685                         */
686                    case '/':
687                    case '\\':
688                        pos += 2;
689                        continue;
690
691                        /*
692                         * two dots in a path: go back one hierarchy.
693                         * foo/bar/../baz -> foo/baz
694                         */
695                    case '.':
696                        // only if we have exactly _two_ dots.
697 if (pos+3 < len && isPathSeparator(s.charAt(pos+3))) {
698                            pos += 3;
699                            int separatorPos = result.length()-1;
700                            while (separatorPos >= 0 &&
701                                   ! isPathSeparator(result
702                                                     .charAt(separatorPos))) {
703                                --separatorPos;
704                            }
705                            if (separatorPos >= 0)
706                                result.setLength(separatorPos);
707                            continue;
708                        }
709                    }
710                }
711            }
712            result.append(c);
713            ++pos;
714        }
715        return result.toString();
716     }
717 }
718
719

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags