Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License.  You can
  * obtain a copy of the License at
  * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
  * or packager/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at packager/legal/LICENSE.txt.
  *
  * GPL Classpath Exception:
  * Oracle designates this particular file as subject to the "Classpath"
  * exception as provided by Oracle in the GPL Version 2 section of the License
  * file that accompanied this code.
  *
  * Modifications:
  * If applicable, add the following below the License Header, with the fields
  * enclosed by brackets [] replaced by your own identifying information:
  * "Portions Copyright [year] [name of copyright owner]"
  *
  * Contributor(s):
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  */
 
 package javax.faces.application;
 
 import java.util.List;
 import java.util.Map;
 

ViewHandler is the pluggablity mechanism for allowing implementations of or applications using the JavaServer Faces specification to provide their own handling of the activities in the Render Response and Restore View phases of the request processing lifecycle. This allows for implementations to support different response generation technologies, as well as alternative strategies for saving and restoring the state of each view. An implementation of this class must be thread-safe.

Please see StateManager for information on how the ViewHandler interacts the StateManager.

Version 2 of the specification formally introduced the concept of View Declaration Language. A View Declaration Language (VDL) is a syntax used to declare user interfaces comprised of instances of JSF javax.faces.component.UIComponents. Any of the responsibilities of the ViewHandler that specifically deal with the VDL sub-system are now the domain of the VDL implementation. These responsibilities are defined on the javax.faces.view.ViewDeclarationLanguage class. The ViewHandler provides getViewDeclarationLanguage(javax.faces.context.FacesContext,java.lang.String) as a convenience method to access the VDL implementation given a viewId.

 
 
 public abstract class ViewHandler {
 
     private static Logger log = Logger.getLogger("javax.faces.application");
    // ------------------------------------------------------ Manifest Constants


    

The key, in the session's attribute set, under which the response character encoding may be stored and retrieved.

    public static final String CHARACTER_ENCODING_KEY =
	"javax.faces.request.charset";


    

Allow the web application to define a list of alternate suffixes for pages containing JSF content. This list is a space separated list of values of the form .<extension>. The first physical resource whose extension matches one of the configured extensions will be the suffix used to create the view ID. If this init parameter is not specified, the default value is taken from the value of the constant DEFAULT_SUFFIX.

    public static final String DEFAULT_SUFFIX_PARAM_NAME = 
	"javax.faces.DEFAULT_SUFFIX";


    

The value to use for the default extension if the webapp is using url extension mapping.

    public static final String DEFAULT_SUFFIX = ".xhtml .view.xml .jsp";
    
    

Allow the web application to define an alternate suffix for Facelet based XHTML pages containing JSF content. If this init parameter is not specified, the default value is taken from the value of the constant DEFAULT_FACELETS_SUFFIX

Since:
2.0
    
    public static final String FACELETS_SUFFIX_PARAM_NAME = 
            "javax.faces.FACELETS_SUFFIX";
    
    

The value to use for the default extension for Facelet based XHTML pages if the webapp is using url extension mapping.

Since:
2.0
    public static final String DEFAULT_FACELETS_SUFFIX = ".xhtml";
    
    

Allow the web application to define a semicolon (;) separated list of strings that is used to forcibly declare that certain pages in the application must be interpreted as using Facelets, regardless of their extension. Each entry in the semicolon (;) separated list of strings is either a file extension, as in *.xhtml, or a resource prefix (starting with '/' and interpreted as relative to the web application root), as in /user/*. The latter class of entry can also take the form of /<filename>.<extension>* such as /login.jsp*. The runtime must also consider the facelets.VIEW_MAPPINGS param name as an alias to this param name for backwards compatibility with existing Facelets applications.

Since:
2.0
    
    public static final String FACELETS_VIEW_MAPPINGS_PARAM_NAME = 
            "javax.faces.FACELETS_VIEW_MAPPINGS";
    // ---------------------------------------------------------- Public Methods


    

Returns an appropriate java.util.Locale to use for this and subsequent requests for the current client.

Parameters:
context javax.faces.context.FacesContext for the current request
Throws:
java.lang.NullPointerException if context is null
     public abstract Locale calculateLocale(FacesContext context);
     
     

Returns the correct character encoding to be used for this request.

The following algorithm is employed.

Since:
1.2
 
     
     public String calculateCharacterEncoding(FacesContext context) {
         ExternalContext extContext = context.getExternalContext();
         Map<String,StringheaderMap = extContext.getRequestHeaderMap();
         String contentType = headerMap.get("Content-Type");
         String charEnc = null;
         
         // look for a charset in the Content-Type header first.
         if (null != contentType) {
             // see if this header had a charset
             String charsetStr = "charset=";
             int len = charsetStr.length();
             int idx = contentType.indexOf(charsetStr);
             
             // if we have a charset in this Content-Type header AND it
             // has a non-zero length.
             if (idx != -1 && idx + len < contentType.length()) {
                 charEnc = contentType.substring(idx + len);
             }
         }
         
         // failing that, look in the session for a previously saved one
         if (null == charEnc) {
             if (null != extContext.getSession(false)) {
                 charEnc = (StringextContext.getSessionMap().get();
             }
         }
         
         return charEnc;
     }


    

Return an appropriate renderKitId for this and subsequent requests from the current client. It is an error for this method to return null.

The default return value is javax.faces.render.RenderKitFactory.HTML_BASIC_RENDER_KIT.

Parameters:
context javax.faces.context.FacesContext for the current request
Throws:
java.lang.NullPointerException if context is null
    public abstract String calculateRenderKitId(FacesContext context);


    

Create and return a new javax.faces.component.UIViewRoot instance initialized with information from the argument FacesContext and viewId. Locate the javax.faces.view.ViewDeclarationLanguage implementation for the VDL used in the view. The argument viewId must be converted to a physical viewId that can refer to an actual resource suitable for use by the ViewDeclarationLanguage javax.faces.view.ViewDeclarationLanguage.createView(javax.faces.context.FacesContext,java.lang.String), which must be called by this method.

Throws:
java.lang.NullPointerException if context is null
    public abstract UIViewRoot createView(FacesContext contextString viewId);

    

Derive and return the viewId from the current request, or the argument input by following the algorithm defined in specification section JSF.7.5.2.

The default implementation of this method simply returns rawViewId unchanged.

Parameters:
context the FacesContext for this request
rawViewId the viewId to derive,
Since:
2.0
    public String deriveViewId(FacesContext contextString rawViewId) {
        return rawViewId;
    }

    

Derive and return the viewId from the current request, or the argument input by following the algorithm defined in specification section JSF.7.5.2. Note that unlike deriveViewId(), this method does not require that a physical view be present.

The default implementation of this method simply returns rawViewId unchanged.

Parameters:
context the FacesContext for this request
rawViewId the viewId to derive,
Since:
2.1
    public String deriveLogicalViewId(FacesContext contextString rawViewId) {
        return rawViewId;
    }
    

    

If the value returned from this method is used as the file argument to the four-argument constructor for java.net.URL (assuming appropriate values are used for the first three arguments), then a client making a request to the toExternalForm() of that URL will select the argument viewId for traversing the JSF lifecycle. Please see section JSF.7.5.2 for the complete specification.

Parameters:
context javax.faces.context.FacesContext for this request
viewId View identifier of the desired view
Throws:
java.lang.IllegalArgumentException if viewId is not valid for this ViewHandler, or does not start with "/".
java.lang.NullPointerException if context or viewId is null.
    public abstract String getActionURL(FacesContext contextString viewId);


    

If the value returned from this method is used as the file argument to the four-argument constructor for java.net.URL (assuming appropriate values are used for the first three arguments), then a client making a request to the toExternalForm() of that URL will select the argument path for direct rendering. If the specified path starts with a slash, it must be treated as context relative; otherwise, it must be treated as relative to the action URL of the current view.

Parameters:
context javax.faces.context.FacesContext for the current request
path Resource path to convert to a URL
Throws:
java.lang.IllegalArgumentException if viewId is not valid for this ViewHandler.
java.lang.NullPointerException if context or path is null.
    public abstract String getResourceURL(FacesContext contextString path);


    

Return a JSF action URL derived from the viewId argument that is suitable to be used by the NavigationHandler to issue a redirect request to the URL using a NonFaces request. Compiliant implementations must implement this method as specified in section JSF.7.5.2. The default implementation simply calls through to getActionURL(javax.faces.context.FacesContext,java.lang.String), passing the arguments context and viewId.

Parameters:
context The FacesContext processing this request
viewId The view identifier of the target page
parameters A mapping of parameter names to one or more values
includeViewParams A flag indicating whether view parameters should be encoded into this URL
Since:
2.0
    public String getRedirectURL(FacesContext context,
                                 String viewId,
                                 Map<String,List<String>>parameters,
                                 boolean includeViewParams) {
        
        return getActionURL(contextviewId);
    }


    

Return a JSF action URL derived from the viewId argument that is suitable to be used as the target of a link in a JSF response. Compiliant implementations must implement this method as specified in section JSF.7.5.2. The default implementation simply calls through to getActionURL(javax.faces.context.FacesContext,java.lang.String), passing the arguments context and viewId.

Parameters:
context The FacesContext processing this request
viewId The view identifier of the target page
parameters A mapping of parameter names to one or more values
includeViewParams A flag indicating whether view parameters should be encoded into this URL
Since:
2.0
    public String getBookmarkableURL(FacesContext context,
                                     String viewId,
                                     Map<String,List<String>> parameters,
                                     boolean includeViewParams) {
        return getActionURL(contextviewId);
    }


    

Return the javax.faces.view.ViewDeclarationLanguage instance used for this ViewHandler instance.

The default implementation must use javax.faces.view.ViewDeclarationLanguageFactory.getViewDeclarationLanguage(java.lang.String) to obtain the appropriate ViewDeclarationLanguage implementation for the argument viewId. Any exceptions thrown as a result of invoking that method must not be swallowed.

The default implementation of this method returns null.

Parameters:
context the FacesContext for this request.
viewId the logical view id, as returned from deriveLogicalViewId(javax.faces.context.FacesContext,java.lang.String) for which the ViewDeclarationLanguage should be returned.
Since:
2.0
                                                              String viewId) {
        return null;
    }

    
    

Initialize the view for the request processing lifecycle.

This method must be called at the beginning of the Restore View Phase of the Request Processing Lifecycle. It is responsible for performing any per-request initialization necessary to the operation of the lifycecle.

The default implementation must perform the following actions. If javax.faces.context.ExternalContext.getRequestCharacterEncoding() returns null, call calculateCharacterEncoding(javax.faces.context.FacesContext) and pass the result, if non-null, into the javax.faces.context.ExternalContext.setRequestCharacterEncoding(java.lang.String) method. If javax.faces.context.ExternalContext.getRequestCharacterEncoding() returns non-null take no action.

Throws:
javax.faces.FacesException if a problem occurs setting the encoding, such as the UnsupportedEncodingException thrown by the underlying Servlet or Portlet technology when the encoding is not supported.
    
    public void initView(FacesContext contextthrows FacesException {
        String encoding = context.getExternalContext().getRequestCharacterEncoding();
        if (null != encoding) {
            return;
        }
        encoding = calculateCharacterEncoding(context);
        if (null != encoding) {
            try {
                context.getExternalContext().setRequestCharacterEncoding(encoding);
            } catch (UnsupportedEncodingException e) {
                // PENDING(edburns): I18N
                String message = "Can't set encoding to: " + encoding +
                        " Exception:" + e.getMessage();
                if (.isLoggable(.)) {
                    .fine(message);
                }
                throw new FacesException(messagee);
                
            }
        }
    }
    

    

Perform whatever actions are required to render the response view to the response object associated with the current javax.faces.context.FacesContext.

Otherwise, the default implementation must obtain a reference to the javax.faces.view.ViewDeclarationLanguage for the viewId of the argument viewToRender and call its javax.faces.view.ViewDeclarationLanguage.renderView(javax.faces.context.FacesContext,javax.faces.component.UIViewRoot) method, returning the result and not swallowing any exceptions thrown by that method.

Parameters:
context javax.faces.context.FacesContext for the current request
viewToRender the view to render
Throws:
java.io.IOException if an input/output error occurs
java.lang.NullPointerException if context or viewToRender is null
javax.faces.FacesException if a servlet error occurs
    public abstract void renderView(FacesContext contextUIViewRoot viewToRender)
        throws IOExceptionFacesException;


    

Perform whatever actions are required to restore the view associated with the specified javax.faces.context.FacesContext and viewId. It may delegate to the restoreView of the associated StateManager to do the actual work of restoring the view. If there is no available state for the specified viewId, return null.

Otherwise, the default implementation must obtain a reference to the javax.faces.view.ViewDeclarationLanguage for this viewId and call its javax.faces.view.ViewDeclarationLanguage.restoreView(javax.faces.context.FacesContext,java.lang.String) method, returning the result and not swallowing any exceptions thrown by that method.

Parameters:
context javax.faces.context.FacesContext for the current request
viewId the view identifier for the current request
Throws:
java.lang.NullPointerException if context is null
javax.faces.FacesException if a servlet error occurs
    public abstract UIViewRoot restoreView(FacesContext contextString viewId);

    
    

Take any appropriate action to either immediately write out the current state information (by calling StateManager.writeState(javax.faces.context.FacesContext,java.lang.Object), or noting where state information should later be written.

This method must do nothing if the current request is an Ajax request. When responding to Ajax requests, the state is obtained by calling StateManager.getViewState(javax.faces.context.FacesContext) and then written into the Ajax response during final encoding (javax.faces.component.UIViewRoot.encodeEnd(javax.faces.context.FacesContext).

Parameters:
context javax.faces.context.FacesContext for the current request
Throws:
java.io.IOException if an input/output error occurs
java.lang.NullPointerException if context is null
    public abstract void writeState(FacesContext contextthrows IOException;
New to GrepCode? Check out our FAQ X