FileDocCategorySizeDatePackage
JspServlet.javaAPI DocGlassfish v2 API17824Wed Aug 29 15:23:14 BST 2007org.apache.jasper.servlet

JspServlet

public class JspServlet extends HttpServlet
The JSP engine (a.k.a Jasper). The servlet container is responsible for providing a URLClassLoader for the web application context Jasper is being used in. Jasper will try get the Tomcat ServletContext attribute for its ServletContext class loader, if that fails, it uses the parent class loader. In either case, it must be a URLClassLoader.
author
Anil K. Vijendran
author
Harish Prabandham
author
Remy Maucherat
author
Kin-man Chung
author
Glenn Nielsen

Fields Summary
private static com.sun.org.apache.commons.logging.Log
log
private ServletContext
context
private ServletConfig
config
private org.apache.jasper.Options
options
private org.apache.jasper.compiler.JspRuntimeContext
rctxt
private int
countErrors
private Object
errorCountLk
private String
httpMethodsString
private HashSet
httpMethodsSet
private ConcurrentHashMap
taglibs
private ConcurrentHashMap
tagFileJarUrls
Constructors Summary
Methods Summary
public voiddestroy()

        if (log.isDebugEnabled()) {
            log.debug("JspServlet.destroy()");
        }

        rctxt.destroy();
        JspApplicationContextImpl.removeJspApplicationContext(context);

        // START GlassFish 750
        taglibs.clear();
        tagFileJarUrls.clear();
        // END GlassFish 750

        // START GlassFish 747
        HashMap tldUriToLocationMap = (HashMap) context.getAttribute(
            Constants.JSP_TLD_URI_TO_LOCATION_MAP);
        if (tldUriToLocationMap != null) {
            tldUriToLocationMap.clear();
        }
        // END GlassFish 747
public intgetJspCount()
Returns the number of JSPs for which JspServletWrappers exist, i.e., the number of JSPs that have been loaded into the webapp with which this JspServlet is associated.

This info may be used for monitoring purposes.

return
The number of JSPs that have been loaded into the webapp with which this JspServlet is associated

        return this.rctxt.getJspCount();
public intgetJspErrorCount()
Gets the number of errors triggered by JSP invocations.

return
The number of errors triggered by JSP invocations

        return this.countErrors;
public intgetJspReloadCount()
Gets the number of JSPs that have been reloaded.

This info may be used for monitoring purposes.

return
The number of JSPs (in the webapp with which this JspServlet is associated) that have been reloaded

        return this.rctxt.getJspReloadCount();
private voidincrementErrorCount()

        synchronized (errorCountLk) {
            countErrors++;
        }
public voidinit(javax.servlet.ServletConfig config)

    // END GlassFish 750

    /*
     * Initializes this JspServlet.
     */
          

        super.init(config);
        this.config = config;
        this.context = config.getServletContext();

        // Initialize the JSP Runtime Context
        options = new EmbeddedServletOptions(config, context);
        rctxt = new JspRuntimeContext(context,options);

        // Instantiate and init our resource injector
        String resourceInjectorClassName = config.getInitParameter(
            Constants.JSP_RESOURCE_INJECTOR_CONTEXT_ATTRIBUTE);
        if (resourceInjectorClassName != null) {
            try {
                ResourceInjector ri = (ResourceInjector)
                    Class.forName(resourceInjectorClassName).newInstance();
                ri.setContext(this.context);
                this.context.setAttribute(
                    Constants.JSP_RESOURCE_INJECTOR_CONTEXT_ATTRIBUTE, ri);
            } catch (Exception e) {
                throw new ServletException(e);
	    }
        }

        // START SJSWS 6232180
        // Determine which HTTP methods to service ("*" means all)
        httpMethodsString = config.getInitParameter("httpMethods");
        if (httpMethodsString != null
                && !httpMethodsString.equals("*")) {
            httpMethodsSet = new HashSet();
            StringTokenizer tokenizer = new StringTokenizer(
                    httpMethodsString, ", \t\n\r\f");
            while (tokenizer.hasMoreTokens()) {
                httpMethodsSet.add(tokenizer.nextToken());
            }
        }
        // END SJSWS 6232180

        // START GlassFish 750
        taglibs = new ConcurrentHashMap<String, TagLibraryInfo>();
        context.setAttribute(Constants.JSP_TAGLIBRARY_CACHE, taglibs);

        tagFileJarUrls = new ConcurrentHashMap<String, URL>();
        context.setAttribute(Constants.JSP_TAGFILE_JAR_URLS_CACHE, 
                             tagFileJarUrls);
        // END GlassFish 750

        if (log.isTraceEnabled()) {
            log.trace(Localizer.getMessage("jsp.message.scratch.dir.is",
                                           options.getScratchDir().toString()));
            log.trace(Localizer.getMessage("jsp.message.dont.modify.servlets"));
        }
booleanpreCompile(javax.servlet.http.HttpServletRequest request)

Look for a precompilation request as described in Section 8.4.2 of the JSP 1.2 Specification. WARNING - we cannot use request.getParameter() for this, because that will trigger parsing all of the request parameters, and not give a servlet the opportunity to call request.setCharacterEncoding() first.

param
request The servlet requset we are processing
exception
ServletException if an invalid parameter value for the jsp_precompile parameter name is specified


        String queryString = request.getQueryString();
        if (queryString == null) {
            return (false);
        }
        int start = queryString.indexOf(Constants.PRECOMPILE);
        if (start < 0) {
            return (false);
        }
        queryString =
            queryString.substring(start + Constants.PRECOMPILE.length());
        if (queryString.length() == 0) {
            return (true);             // ?jsp_precompile
        }
        if (queryString.startsWith("&")) {
            return (true);             // ?jsp_precompile&foo=bar...
        }
        if (!queryString.startsWith("=")) {
            return (false);            // part of some other name or value
        }
        int limit = queryString.length();
        int ampersand = queryString.indexOf("&");
        if (ampersand > 0) {
            limit = ampersand;
        }
        String value = queryString.substring(1, limit);
        if (value.equals("true")) {
            return (true);             // ?jsp_precompile=true
        } else if (value.equals("false")) {
	    // Spec says if jsp_precompile=false, the request should not
	    // be delivered to the JSP page; the easiest way to implement
	    // this is to set the flag to true, and precompile the page anyway.
	    // This still conforms to the spec, since it says the
	    // precompilation request can be ignored.
            return (true);             // ?jsp_precompile=false
        } else {
            throw new ServletException("Cannot have request parameter " +
                                       Constants.PRECOMPILE + " set to " +
                                       value);
        }
public voidservice(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)


        // START SJSWS 6232180
        if (httpMethodsSet != null) {
            String method = request.getMethod();
            if (method == null) {
                return;
            }
            boolean isSupportedMethod = httpMethodsSet.contains(method);
            if (!isSupportedMethod) {
                if (method.equals("OPTIONS")) {
                    response.addHeader("Allow", httpMethodsString);
                } else {
                    super.service(request, response);
                }
                return;
            }
        }
        // END SJSWS 6232180

        String jspUri = null;

        String jspFile = (String) request.getAttribute(Constants.JSP_FILE);
        if (jspFile != null) {
            // JSP is specified via <jsp-file> in <servlet> declaration
            jspUri = jspFile;
            request.removeAttribute(Constants.JSP_FILE);
        } else {
            /*
             * Check to see if the requested JSP has been the target of a
             * RequestDispatcher.include()
             */
            jspUri = (String) request.getAttribute(Constants.INC_SERVLET_PATH);
            if (jspUri != null) {
                /*
		 * Requested JSP has been target of
                 * RequestDispatcher.include(). Its path is assembled from the
                 * relevant javax.servlet.include.* request attributes
                 */
                String pathInfo = (String) request.getAttribute(
                                    "javax.servlet.include.path_info");
                if (pathInfo != null) {
                    jspUri += pathInfo;
                }
            } else {
                /*
                 * Requested JSP has not been the target of a 
                 * RequestDispatcher.include(). Reconstruct its path from the
                 * request's getServletPath() and getPathInfo()
                 */
                jspUri = request.getServletPath();
                String pathInfo = request.getPathInfo();
                if (pathInfo != null) {
                    jspUri += pathInfo;
                }
            }
        }

        if (log.isDebugEnabled()) {	    
            StringBuffer msg = new StringBuffer();
            msg.append("JspEngine --> [" + jspUri);
            msg.append("] ServletPath: [" + request.getServletPath());
            msg.append("] PathInfo: [" + request.getPathInfo());
            msg.append("] RealPath: [" + context.getRealPath(jspUri));
            msg.append("] RequestURI: [" + request.getRequestURI());
            msg.append("] QueryString: [" + request.getQueryString());
            msg.append("]");
            log.debug(msg);
        }

        try {
            boolean precompile = preCompile(request);
            serviceJspFile(request, response, jspUri, null, precompile);
        } catch (RuntimeException e) {
            // STARTS S1AS
            incrementErrorCount();
            // END S1AS
            throw e;
        } catch (ServletException e) {
            // STARTS S1AS
            incrementErrorCount();
            // END S1AS
            throw e;
        } catch (IOException e) {
            // STARTS S1AS
            incrementErrorCount();
            // END S1AS
            throw e;
        } catch (Throwable e) {
            // STARTS S1AS
            incrementErrorCount();
            // END S1AS
            throw new ServletException(e);
        }
private voidserviceJspFile(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response, java.lang.String jspUri, java.lang.Throwable exception, boolean precompile)


        JspServletWrapper wrapper =
            (JspServletWrapper) rctxt.getWrapper(jspUri);
        if (wrapper == null) {
            synchronized(this) {
                wrapper = (JspServletWrapper) rctxt.getWrapper(jspUri);
                if (wrapper == null) {
                    // Check if the requested JSP page exists, to avoid
                    // creating unnecessary directories and files.
                    /* START PWC 6181923
                    if (null == context.getResource(jspUri)) {
                    */
                    // START PWC 6181923
                    if (null == context.getResource(jspUri)
                            && !options.getUsePrecompiled()) {
                    // END PWC 6181923

                        // START PWC 6300204
                        String includeRequestUri = (String) 
                            request.getAttribute("javax.servlet.include.request_uri");
                        if (includeRequestUri != null) {
                            // Missing JSP resource has been the target of a
                            // RequestDispatcher.include().
                            // Throw an exception (rather than returning a 
                            // 404 response error code), because any call to
                            // response.sendError() must be ignored by the
                            // servlet engine when issued from within an
                            // included resource (as per the Servlet spec).
                            throw new FileNotFoundException(jspUri);
                        }
                        // END PWC 6300204

                        /* RIMOD PWC 6282167, 4878272
                        response.sendError(HttpServletResponse.SC_NOT_FOUND,
                                           jspUri);
                        */
                        // START PWC 6282167, 4878272
                        response.sendError(HttpServletResponse.SC_NOT_FOUND);
                        log.error(Localizer.getMessage(
                            "jsp.error.file.not.found",
                            context.getRealPath(jspUri)));
                        // END PWC 6282167, 4878272
                        return;
                    }
                    boolean isErrorPage = exception != null;
                    wrapper = new JspServletWrapper(config, options, jspUri,
                                                    isErrorPage, rctxt);
                    rctxt.addWrapper(jspUri,wrapper);
                }
            }
        }

        wrapper.service(request, response, precompile);
public voidsetJspReloadCount(int count)
Resets the JSP reload counter.

param
count Value to which to reset the JSP reload counter

        this.rctxt.setJspReloadCount(count);