Save This Page
Home » Mojarra-2.0.1 » javax » faces » webapp » [javadoc | source]
    1   /*
    2    * $Id: FacesServlet.java,v 1.38 2008/01/25 16:36:32 edburns Exp $
    3    */
    4   
    5   /*
    6    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    7    * 
    8    * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
    9    * 
   10    * The contents of this file are subject to the terms of either the GNU
   11    * General Public License Version 2 only ("GPL") or the Common Development
   12    * and Distribution License("CDDL") (collectively, the "License").  You
   13    * may not use this file except in compliance with the License. You can obtain
   14    * a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
   15    * or glassfish/bootstrap/legal/LICENSE.txt.  See the License for the specific
   16    * language governing permissions and limitations under the License.
   17    * 
   18    * When distributing the software, include this License Header Notice in each
   19    * file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
   20    * Sun designates this particular file as subject to the "Classpath" exception
   21    * as provided by Sun in the GPL Version 2 section of the License file that
   22    * accompanied this code.  If applicable, add the following below the License
   23    * Header, with the fields enclosed by brackets [] replaced by your own
   24    * identifying information: "Portions Copyrighted [year]
   25    * [name of copyright owner]"
   26    * 
   27    * Contributor(s):
   28    * 
   29    * If you wish your version of this file to be governed by only the CDDL or
   30    * only the GPL Version 2, indicate your decision by adding "[Contributor]
   31    * elects to include this software in this distribution under the [CDDL or GPL
   32    * Version 2] license."  If you don't indicate a single choice of license, a
   33    * recipient has the option to distribute your version of this file under
   34    * either the CDDL, the GPL Version 2 or to extend the choice of license to
   35    * its licensees as provided above.  However, if you add GPL Version 2 code
   36    * and therefore, elected the GPL Version 2 license, then the option applies
   37    * only if the new code is made subject to such option by the copyright
   38    * holder.
   39    */
   40   
   41   package javax.faces.webapp;
   42   
   43   
   44   import java.io.IOException;
   45   import java.util.ResourceBundle;
   46   import java.util.logging.Level;
   47   import java.util.logging.Logger;
   48   
   49   import javax.faces.FacesException;
   50   import javax.faces.FactoryFinder;
   51   import javax.faces.application.ResourceHandler;
   52   import javax.faces.context.FacesContext;
   53   import javax.faces.context.FacesContextFactory;
   54   import javax.faces.lifecycle.Lifecycle;
   55   import javax.faces.lifecycle.LifecycleFactory;
   56   import javax.servlet.Servlet;
   57   import javax.servlet.ServletConfig;
   58   import javax.servlet.ServletException;
   59   import javax.servlet.ServletRequest;
   60   import javax.servlet.ServletResponse;
   61   import javax.servlet.UnavailableException;
   62   import javax.servlet.http.HttpServletRequest;
   63   import javax.servlet.http.HttpServletResponse;
   64   
   65   
   66   /**
   67    * <p><strong class="changed_modified_2_0">FacesServlet</strong> is a
   68    * servlet that manages the request processing lifecycle for web
   69    * applications that are utilizing JavaServer Faces to construct the
   70    * user interface.</p>
   71    */
   72   
   73   public final class FacesServlet implements Servlet {
   74   
   75   
   76       /**
   77        * <p>Context initialization parameter name for a comma delimited list
   78        * of context-relative resource paths (in addition to
   79        * <code>/WEB-INF/faces-config.xml</code> which is loaded automatically
   80        * if it exists) containing JavaServer Faces configuration information.</p>
   81        */
   82       public static final String CONFIG_FILES_ATTR =
   83           "javax.faces.CONFIG_FILES";
   84   
   85   
   86       /**
   87        * <p>Context initialization parameter name for the lifecycle identifier
   88        * of the {@link Lifecycle} instance to be utilized.</p>
   89        */
   90       public static final String LIFECYCLE_ID_ATTR =
   91           "javax.faces.LIFECYCLE_ID";
   92   
   93   
   94       /**
   95        * The <code>Logger</code> for this class.
   96        */
   97       private static final Logger LOGGER =
   98             Logger.getLogger("javax.faces.webapp", "javax.faces.LogStrings");
   99   
  100   
  101       /**
  102        * <p>Factory for {@link FacesContext} instances.</p>
  103        */
  104       private FacesContextFactory facesContextFactory = null;
  105   
  106   
  107       /**
  108        * <p>The {@link Lifecycle} instance to use for request processing.</p>
  109        */
  110       private Lifecycle lifecycle = null;
  111   
  112   
  113       /**
  114        * <p>The <code>ServletConfig</code> instance for this servlet.</p>
  115        */
  116       private ServletConfig servletConfig = null;
  117   
  118   
  119       /**
  120        * <p>Release all resources acquired at startup time.</p>
  121        */
  122       public void destroy() {
  123   
  124           facesContextFactory = null;
  125           lifecycle = null;
  126           servletConfig = null;
  127   
  128       }
  129   
  130   
  131       /**
  132        * <p>Return the <code>ServletConfig</code> instance for this servlet.</p>
  133        */
  134       public ServletConfig getServletConfig() {
  135   
  136           return (this.servletConfig);
  137   
  138       }
  139   
  140   
  141       /**
  142        * <p>Return information about this Servlet.</p>
  143        */
  144       public String getServletInfo() {
  145   
  146           return (this.getClass().getName());
  147   
  148       }
  149   
  150   
  151       /**
  152        * <p>Acquire the factory instances we will require.</p>
  153        *
  154        * @throws ServletException if, for any reason, the startup of
  155        * this Faces application failed.  This includes errors in the
  156        * config file that is parsed before or during the processing of
  157        * this <code>init()</code> method.
  158        */
  159       public void init(ServletConfig servletConfig) throws ServletException {
  160   
  161           // Save our ServletConfig instance
  162           this.servletConfig = servletConfig;
  163   
  164           // Acquire our FacesContextFactory instance
  165           try {
  166               facesContextFactory = (FacesContextFactory)
  167                   FactoryFinder.getFactory
  168                   (FactoryFinder.FACES_CONTEXT_FACTORY);
  169           } catch (FacesException e) {
  170               ResourceBundle rb = LOGGER.getResourceBundle();
  171               String msg = rb.getString("severe.webapp.facesservlet.init_failed");
  172               Throwable rootCause = (e.getCause() != null) ? e.getCause() : e;
  173               LOGGER.log(Level.SEVERE, msg, rootCause);
  174               throw new UnavailableException(msg);
  175           }
  176   
  177           // Acquire our Lifecycle instance
  178           try {
  179               LifecycleFactory lifecycleFactory = (LifecycleFactory)
  180                   FactoryFinder.getFactory(FactoryFinder.LIFECYCLE_FACTORY);
  181               String lifecycleId ;
  182   
  183               // First look in the servlet init-param set
  184               if (null == (lifecycleId = servletConfig.getInitParameter(LIFECYCLE_ID_ATTR))) {
  185                   // If not found, look in the context-param set 
  186                   lifecycleId = servletConfig.getServletContext().getInitParameter
  187                       (LIFECYCLE_ID_ATTR);
  188               }
  189   
  190               if (lifecycleId == null) {
  191                   lifecycleId = LifecycleFactory.DEFAULT_LIFECYCLE;
  192               }
  193               lifecycle = lifecycleFactory.getLifecycle(lifecycleId);
  194           } catch (FacesException e) {
  195               Throwable rootCause = e.getCause();
  196               if (rootCause == null) {
  197                   throw e;
  198               } else {
  199                   throw new ServletException(e.getMessage(), rootCause);
  200               }
  201           }
  202   
  203       }
  204   
  205   
  206       /**
  207        * <p class="changed_modified_2_0">Process an incoming request, and create the
  208        * corresponding response according to the following
  209        * specification.</p>
  210        * 
  211        * <div class="changed_modified_2_0">
  212        *
  213        * <p>If the <code>request</code> and <code>response</code>
  214        * arguments to this method are not instances of
  215        * <code>HttpServletRequest</code> and
  216        * <code>HttpServletResponse</code>, respectively, the results of
  217        * invoking this method are undefined.</p>
  218        *
  219        * <p>This method must respond to requests that start with the
  220        * following strings by invoking the <code>sendError</code> method
  221        * on the response argument (cast to
  222        * <code>HttpServletResponse</code>), passing the code
  223        * <code>HttpServletResponse.SC_NOT_FOUND</code> as the
  224        * argument. </p>
  225        *
  226        * <ul>
  227        *
  228   <pre><code>
  229   /WEB-INF/
  230   /WEB-INF
  231   /META-INF/
  232   /META-INF
  233   </code></pre>
  234        *
  235        * </ul>
  236        *
  237        
  238        * <p>If none of the cases described above in the specification for
  239        * this method apply to the servicing of this request, the following
  240        * action must be taken to service the request.</p>
  241   
  242        * <p>Acquire a {@link FacesContext} instance for this request.</p>
  243   
  244        * <p>Acquire the <code>ResourceHandler</code> for this request by
  245        * calling {@link
  246        * javax.faces.application.Application#getResourceHandler}.  Call
  247        * {@link
  248        * javax.faces.application.ResourceHandler#isResourceRequest}.  If
  249        * this returns <code>true</code> call {@link
  250        * javax.faces.application.ResourceHandler#handleResourceRequest}.
  251        * If this returns <code>false</code>, call {@link
  252        * javax.faces.lifecycle.Lifecycle#execute} followed by {@link
  253        * javax.faces.lifecycle.Lifecycle#render}.  If a {@link
  254        * javax.faces.FacesException} is thrown in either case, extract the
  255        * cause from the <code>FacesException</code>.  If the cause is
  256        * <code>null</code> extract the message from the
  257        * <code>FacesException</code>, put it inside of a new
  258        * <code>ServletException</code> instance, and pass the
  259        * <code>FacesException</code> instance as the root cause, then
  260        * rethrow the <code>ServletException</code> instance.  If the cause
  261        * is an instance of <code>ServletException</code>, rethrow the
  262        * cause.  If the cause is an instance of <code>IOException</code>,
  263        * rethrow the cause.  Otherwise, create a new
  264        * <code>ServletException</code> instance, passing the message from
  265        * the cause, as the first argument, and the cause itself as the
  266        * second argument.</p>
  267   
  268        * In a finally block, {@link
  269        * javax.faces.context.FacesContext#release} must be called.
  270   
  271        * </div>
  272        *
  273        * @param request The servlet request we are processing
  274        * @param response The servlet response we are creating
  275        *
  276        * @throws IOException if an input/output error occurs during processing
  277        * @throws ServletException if a servlet error occurs during processing
  278   
  279        */
  280       public void service(ServletRequest request,
  281                           ServletResponse response)
  282           throws IOException, ServletException {
  283   
  284           // If prefix mapped, then ensure requests for /WEB-INF are
  285           // not processed.
  286           String pathInfo = ((HttpServletRequest) request).getPathInfo();
  287           if (pathInfo != null) {
  288               pathInfo = pathInfo.toUpperCase();
  289               if (pathInfo.startsWith("/WEB-INF/")
  290                   || pathInfo.equals("/WEB-INF")
  291                   || pathInfo.startsWith("/META-INF/")
  292                   || pathInfo.equals("/META-INF")) {
  293                   ((HttpServletResponse) response).
  294                         sendError(HttpServletResponse.SC_NOT_FOUND);
  295                   return;
  296               }
  297           }    
  298           
  299           // Acquire the FacesContext instance for this request
  300           FacesContext context = facesContextFactory.getFacesContext
  301                 (servletConfig.getServletContext(), request, response, lifecycle);
  302   
  303           // Execute the request processing lifecycle for this request
  304           try {
  305               ResourceHandler handler =
  306                     context.getApplication().getResourceHandler();
  307               if (handler.isResourceRequest(context)) {
  308                   handler.handleResourceRequest(context);
  309               } else {
  310                   lifecycle.execute(context);
  311                   lifecycle.render(context);
  312               }
  313           } catch (FacesException e) {
  314               Throwable t = e.getCause();
  315               if (t == null) {
  316                   throw new ServletException(e.getMessage(), e);
  317               } else {
  318                   if (t instanceof ServletException) {
  319                       throw ((ServletException) t);
  320                   } else if (t instanceof IOException) {
  321                       throw ((IOException) t);
  322                   } else {
  323                       throw new ServletException(t.getMessage(), t);
  324                   }
  325               }
  326           }
  327           finally {
  328               // Release the FacesContext instance for this request
  329               context.release();
  330           }
  331       }
  332   
  333   }

Save This Page
Home » Mojarra-2.0.1 » javax » faces » webapp » [javadoc | source]