String identifier for BASIC authentication.

String identifier for CLIENT_CERT authentication.

String identifier for DIGEST authentication.

String identifier for FORM authentication.

 public  void addResponseCookie(String name,
    String value,
    Map<String, Object> properties) 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.addResponseCookie(name, value, properties);
        } else {
            throw new UnsupportedOperationException();
        }
}

Adds the cookie represented by the arguments to the response.

Servlet: This must be accomplished by calling the javax.servlet.http.HttpServletResponse method addCookie(). The Cookie argument must be constructed by passing the name and value parameters. If the properties arugument is non-null and not empty, the Cookie instance must be initialized as described below.

Key in "values" Map	Expected type of value.	Name of setter method on Cookie instance to be set with the value from the Map.
comment	String	setComment
domain	String	setDomain
maxAge	Integer	setMaxAge
secure	Boolean	setSecure
path	String	setPath

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void addResponseHeader(String name,
    String value) 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.addResponseHeader(name, value);
        } else {
            throw new UnsupportedOperationException();
        }
}

Add the given name and value to the response header.

Servlet:This must be performed by calling the javax.servlet.http.HttpServletResponse addHeader method.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 abstract public  void dispatch(String path) throws IOException
Dispatch a request to the specified resource to create output
for this response.

Servlet: This must be accomplished by calling the
javax.servlet.ServletContext method
getRequestDispatcher(path), and calling the
forward() method on the resulting object.

 abstract public String encodeActionURL(String url)
Return the input URL, after performing any rewriting needed to
ensure that it will correctly identify an addressable action in the
current application.


Servlet: This must be the value returned by the
javax.servlet.http.HttpServletResponse method
encodeURL(url).

 public String encodeBookmarkableURL(String baseUrl,
    Map<String> parameters) 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.encodeBookmarkableURL(baseUrl,
                                                                parameters);
        }
        throw new UnsupportedOperationException();
}

The purpose of this method is to generate a query string from the collection of Parameter objects provided by the parameters argument and append that query string to the baseUrl. This method must be able to encode the parameters to a baseUrl that may or may not have existing query parameters. The parameter values should be encoded appropriately for the environment so that the resulting URL can be used as the target of a link (e.g., in an href attribute) in a JSF response. It's possible for an ExternalContext implementation to override this method in any way that would make the URL bookmarkable in that environment.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 abstract public String encodeNamespace(String name)
Return the specified name, after prefixing it with a namespace
that ensures that it will be unique within the context of a
particular page.

Servlet: The input value must be returned unchanged.

 public String encodePartialActionURL(String url) 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.encodePartialActionURL(url);
        }
        throw new UnsupportedOperationException();
}

Return the input URL, after performing any rewriting needed to ensure that it can be used in a partial page submission (ajax request) to correctly identify an addressable action in the current application.

Servlet:Returns the same encoded URL as the #encodeActionURL(String url) method.

Portlet:Returns an encoded URL that, upon HTTP POST, will invoke the RESOURCE_PHASE of the portlet lifecycle.

 public String encodeRedirectURL(String baseUrl,
    Map<String> parameters) 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.encodeRedirectURL(baseUrl, parameters);
        }
        throw new UnsupportedOperationException();
}

The purpose of this method is to generate a query string from the collection of Parameter objects provided by the parameters argument and append that query string to the baseUrl. This method must be able to encode the parameters to a baseUrl that may or may not have existing query parameters. The parameter values should be encoded appropriately for the environment so that the resulting URL can be used as the target of a redirect. It's possible for an ExternalContext implementation to override this method to accomodate the definition of redirect for that environment.

 abstract public String encodeResourceURL(String url)
Return the input URL, after performing any rewriting needed to
ensure that it will correctly identify an addressable resource in the
current application.


Servlet: This must be the value returned by the
javax.servlet.http.HttpServletResponse method
encodeURL(url).

 abstract public Map<String, Object> getApplicationMap()
Return a mutable
Map representing the application scope attributes
for the current application.  The returned Map must
implement the entire contract for a modifiable map as described
in the JavaDocs for java.util.Map.  Modifications
made in the Map must cause the corresponding changes
in the set of application scope attributes.  Particularly the
clear(), remove(), put(),
putAll(), and get() operations must
take the appropriate action on the underlying data structure.

For any of the Map methods that cause an element
to be removed from the underlying data structure, the following
action regarding managed-beans must be taken.  If the element to
be removed is a managed-bean, and it has one or more public
no-argument void return methods annotated with
javax.annotation.PreDestroy, each such method must
be called before the element is removed from the underlying data
structure.  Elements that are not managed-beans, but do happen to
have methods with that annotation must not have those methods
called on removal.  Any exception thrown by the
PreDestroy annotated methods must by caught and not
rethrown.  The exception may be logged.

It is valid to call this method
during application startup or shutdown.  If called at startup or shutdown time, this
method returns a Map that is backed by the same
container context instance (ServletContext or
PortletContext) as the one returned by calling
getApplicationMap() on the
ExternalContext returned by the
FacesContext during an actual request.

Servlet:  This must be the set of attributes available via
the javax.servlet.ServletContext methods
getAttribute(), getAttributeNames(),
removeAttribute(), and setAttribute().

 abstract public String getAuthType()
Return the name of the authentication scheme used to authenticate
the current user, if any; otherwise, return null.
For standard authentication schemes, the returned value will match
one of the following constants:
BASIC_AUTH, CLIENT_CERT_AUTH,
DIGEST_AUTH, or FORM_AUTH.

Servlet: This must be the value returned by the
javax.servlet.http.HttpServletRequest method
getAuthType().

 abstract public Object getContext()
Return the
application environment object instance for the current
appication.

It is valid to call this method
during application startup or shutdown.  If called during application
startup or shutdown, this returns the same container context instance
(ServletContext or PortletContext) as
the one returned when calling getContext() on the
ExternalContext returned by the
FacesContext during an actual request.


Servlet:  This must be the current application's
javax.servlet.ServletContext instance.

 public String getContextName() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getContextName();
        }
        throw new UnsupportedOperationException();
}

Return the name of the container context for this application.

Return the result of calling getServletContextName() on the ServletContext instance for this application. It is valid to call this method during application startup or shutdown.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public Flash getFlash() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getFlash();
        }
        throw new UnsupportedOperationException();
}

Return the threadsafe Flash for this application. The default implementation will throw UnsupportedOperationException. Compliant JSF runtimes must provide an implementation of this method.

 abstract public String getInitParameter(String name)
Return the value of
the specified application initialization parameter (if any).

Servlet: This must be the result of the
javax.servlet.ServletContext method
getInitParameter(name).

It is valid to call this method
during application startup or shutdown.  If called during application
startup or shutdown, this method calls through to the actual container
context to return the init parameter value.

 abstract public Map getInitParameterMap()
Return an
immutable Map whose keys are the set of application
initialization parameter names configured for this application,
and whose values are the corresponding parameter values.  The
returned Map must implement the entire contract for
an unmodifiable map as described in the JavaDocs for
java.util.Map.

It is valid to call this method
during application startup or shutdown.  If called during application
startup or shutdown, this method returns a Map that is backed by
the same container context instance (ServletContext
or PortletContext) as the one returned by calling
getInitParameterMap() on the
ExternalContext returned by the
FacesContext during an actual request.

Servlet: This result must be as if it were synthesized
by calling the javax.servlet.ServletContext
method getInitParameterNames, and putting
each configured parameter name/value pair into the result.

 public String getMimeType(String file) 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getMimeType(file);
        }
        throw new UnsupportedOperationException();
}

Returns the MIME type of the specified file or null if the MIME type is not known. The MIME type is determined by the container.

It is valid to call this method during application startup or shutdown. If called during application startup or shutdown, this method calls through to the getMimeType() method on the same container context instance (ServletContext or PortletContext) as the one used when calling getMimeType() on the ExternalContext returned by the FacesContext during an actual request.

Servlet: This must be the value returned by the javax.servlet.ServletContext method getMimeType().

 public String getRealPath(String path) 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getRealPath(path);
        }
        throw new UnsupportedOperationException();
}

Returns a String containing the real path for a given virtual path.

Servlet: This must be the value returned by the javax.servlet.ServletContext method getRealPath().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 abstract public String getRemoteUser()
Return the login name of the user making the current request
if any; otherwise, return null.

Servlet: This must be the value returned by the
javax.servlet.http.HttpServletRequest method
getRemoteUser().

 abstract public Object getRequest()
Return the environment-specific object instance for the current
request.

Servlet:  This must be the current request's
javax.servlet.http.HttpServletRequest instance.

 public String getRequestCharacterEncoding() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getRequestCharacterEncoding();
        }
        throw new UnsupportedOperationException();
}

Return the character encoding currently being used to interpret this request.

Servlet: This must return the value returned by the javax.servlet.ServletRequest method getCharacterEncoding().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public int getRequestContentLength() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getRequestContentLength();
        }
        throw new UnsupportedOperationException();
}

Return the result of calling getContentLenth() on the ServletRequest instance for this request.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public String getRequestContentType() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getRequestContentType();
        }
        throw new UnsupportedOperationException();
}

Return the MIME Content-Type for this request. If not available, return null.

Servlet: This must return the value returned by the javax.servlet.ServletRequest method getContentType().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 abstract public String getRequestContextPath()
Return the portion of the request URI that identifies the web
application context for this request.

Servlet: This must be the value returned by the
javax.servlet.http.HttpServletRequest method
getContextPath().

 abstract public Map<String, Object> getRequestCookieMap()
Return an immutable Map whose keys are the set of
cookie names included in the current request, and whose
values (of type javax.servlet.http.Cookie)
are the first (or only) cookie for each cookie name
returned by the underlying request.  The returned
Map must implement the entire contract for an unmodifiable
map as described in the JavaDocs for java.util.Map.

Servlet: This must be the value returned by the
javax.servlet.http.HttpServletRequest method
getCookies(), unless null was returned,
in which case this must be a zero-length array.

 abstract public Map<String, String> getRequestHeaderMap()
Return an immutable Map whose keys are the set of
request header names included in the current request, and whose
values (of type String) are the first (or only) value for each
header name returned by the underlying request.  The returned
Map must implement the entire contract for an unmodifiable
map as described in the JavaDocs for java.util.Map.  In
addition, key comparisons must be performed in a case insensitive
manner.

Servlet: This must be the set of headers available via
the javax.servlet.http.HttpServletRequest methods
getHeader() and getHeaderNames().

 abstract public Map<String, String> getRequestHeaderValuesMap()
Return an immutable Map whose keys are the set of
request header names included in the current request, and whose
values (of type String[]) are all of the value for each
header name returned by the underlying request.  The returned
Map must implement the entire contract for an unmodifiable
map as described in the JavaDocs for java.util.Map.  In
addition, key comparisons must be performed in a case insensitive
manner.

Servlet: This must be the set of headers available via
the javax.servlet.http.HttpServletRequest methods
getHeaders() and getHeaderNames().

 abstract public Locale getRequestLocale()
Return the preferred Locale in which the client
will accept content.

Servlet: This must be the value returned by the
javax.servlet.ServletRequest method
getLocale().

 abstract public Iterator<Locale> getRequestLocales()
Return an Iterator over the preferred
Locales specified in the request, in decreasing
order of preference.

Servlet: This must be an Iterator
over the values returned by the javax.servlet.ServletRequest
method getLocales().

 abstract public Map<String, Object> getRequestMap()
Return a mutable Map representing the request
scope attributes for the current application.  The returned
Map must implement the entire contract for a
modifiable map as described in the JavaDocs for
java.util.Map.  Modifications made in the
Map must cause the corresponding changes in the set
of request scope attributes.  Particularly the
clear(), remove(), put(),
putAll(), and get() operations must
take the appropriate action on the underlying data structure.

For any of the Map methods that cause an element
to be removed from the underlying data structure, the following
action regarding managed-beans must be taken.  If the element to
be removed is a managed-bean, and it has one or more public
no-argument void return methods annotated with
javax.annotation.PreDestroy, each such method must
be called before the element is removed from the underlying data
structure.  Elements that are not managed-beans, but do happen to
have methods with that annotation must not have those methods
called on removal.  Any exception thrown by the
PreDestroy annotated methods must by caught and not
rethrown.  The exception may be logged.

Servlet:  This must be the set of attributes available via
the javax.servlet.ServletRequest methods
getAttribute(), getAttributeNames(),
removeAttribute(), and setAttribute().

 abstract public Map<String, String> getRequestParameterMap()
Return an immutable Map whose keys are the set of
request parameters names included in the current request, and whose
values (of type String) are the first (or only) value for each
parameter name returned by the underlying request.  The returned
Map must implement the entire contract for an unmodifiable
map as described in the JavaDocs for java.util.Map.

Servlet: This must be the set of parameters available via
the javax.servlet.ServletRequest methods
getParameter() and getParameterNames().

 abstract public Iterator<String> getRequestParameterNames()
Return an Iterator over the names of all request
parameters included in the current request.

Servlet: This must be an Iterator over the
values returned by the javax.servlet.ServletRequest
method getParameterNames().

 abstract public Map<String, String> getRequestParameterValuesMap()
Return an immutable Map whose keys are the set of
request parameters names included in the current request, and whose
values (of type String[]) are all of the values for each
parameter name returned by the underlying request.  The returned
Map must implement the entire contract for an unmodifiable
map as described in the JavaDocs for java.util.Map.

Servlet: This must be the set of parameters available via
the javax.servlet.ServletRequest methods
getParameterValues() and
getParameterNames().

 abstract public String getRequestPathInfo()
Return the extra path information (if any) included in the
request URI; otherwise, return null.

Servlet: This must be the value returned by the
javax.servlet.http.HttpServletRequest method
getPathInfo().

 public String getRequestScheme() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getRequestScheme();
        }
        throw new UnsupportedOperationException();
}

Returns the name of the scheme used to make this request, for example, http, https, or ftp.

Servlet: This must be the value returned by the javax.servlet.ServletRequest method getScheme().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public String getRequestServerName() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getRequestServerName();
        }
        throw new UnsupportedOperationException();
}

Returns the host name of the server to which the request was sent.

Servlet: This must be the value returned by the javax.servlet.ServletRequest method getServerName().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public int getRequestServerPort() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getRequestServerPort();
        }
        throw new UnsupportedOperationException();
}

Returns the port number to which the request was sent.

Servlet: This must be the value returned by the javax.servlet.ServletRequest method getServerPort().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 abstract public String getRequestServletPath()
Return the servlet path information (if any) included in the
request URI; otherwise, return null.

Servlet: This must be the value returned by the
javax.servlet.http.HttpServletRequest method
getServletPath().

 abstract public URL getResource(String path) throws MalformedURLException
Return a
URL for the application resource mapped to the
specified path, if it exists; otherwise, return
null.

It is valid to call this method
during application startup or shutdown.  If called during application
startup or shutdown, this method calls through to the
getResource() method on the same container
context instance (ServletContext or
PortletContext) as the one used when calling
getResource() on the
ExternalContext returned by the
FacesContext during an actual request.

Servlet: This must be the value returned by the
javax.servlet.ServletContext method
getResource(path).

 abstract public InputStream getResourceAsStream(String path)
Return an
InputStream for an application resource mapped to
the specified path, if it exists; otherwise, return
null.

It is valid to call this method
during application startup or shutdown.  If called during application
startup or shutdown, this method calls through to the
getResourceAsStream() method on the same container
context instance (ServletContext or
PortletContext) as the one used when calling
getResourceAsStream() on the
ExternalContext returned by the
FacesContext during an actual request.

Servlet: This must be the value returned by the
javax.servlet.ServletContext method
getResourceAsStream(path).

 abstract public Set<String> getResourcePaths(String path)
Return the
Set of resource paths for all application resources
whose resource path starts with the specified argument.

It is valid to call this method
during application startup or shutdown.  If called during application
startup or shutdown, this method calls through to the
getResourcePaths() method on the same container
context instance (ServletContext or
PortletContext) as the one used when calling
getResourcePaths() on the
ExternalContext returned by the
FacesContext during an actual request.

Servlet: This must be the value returned by the
javax.servlet.ServletContext method
getResourcePaths(path).

 abstract public Object getResponse()
Return the environment-specific object instance for the current
response.

Servlet:  This is the current request's
javax.servlet.http.HttpServletResponse instance.

 public int getResponseBufferSize() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getResponseBufferSize();
        }
        throw new UnsupportedOperationException();
}

Return the buffer size for the current response.

Servlet: This must be performed by calling the javax.servlet.http.HttpServletResponse getBufferSize method.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public String getResponseCharacterEncoding() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getResponseCharacterEncoding();
        }
        throw new UnsupportedOperationException();
}

Returns the name of the character encoding (MIME charset) used for the body sent in this response.

Servlet: This must return the value returned by the javax.servlet.ServletResponse method getCharacterEncoding().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public String getResponseContentType() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getResponseContentType();
        }
        throw new UnsupportedOperationException();
}

Return the MIME Content-Type for this response. If not available, return null.

Servlet: This must return the value returned by the javax.servlet.ServletResponse method getContentType().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public OutputStream getResponseOutputStream() throws IOException 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getResponseOutputStream();
        }
        throw new UnsupportedOperationException();
}

Returns an OutputStream suitable for writing binary data to the user-agent.

Servlet: This must return the value returned by the javax.servlet.ServletResponse method getOutputStream().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public Writer getResponseOutputWriter() throws IOException 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.getResponseOutputWriter();
        }
        throw new UnsupportedOperationException();
}

Returns a Writer suitable for writing character data to the user-agent.

Servlet: This must return the value returned by the javax.servlet.ServletResponse#getWriter .

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 abstract public Object getSession(boolean create)
If the create parameter is true,
create (if necessary) and return a session instance associated
with the current request.  If the create parameter
is false return any existing session instance
associated with the current request, or return null if
there is no such session.

Servlet: This must return the result of calling
getSession(create) on the underlying
javax.servlet.http.HttpServletRequest instance.

 abstract public Map<String, Object> getSessionMap()
Return a mutable Map representing the session
scope attributes for the current application.  The returned
Map must implement the entire contract for a
modifiable map as described in the JavaDocs for
java.util.Map.  Modifications made in the
Map must cause the corresponding changes in the set
of session scope attributes.  Particularly the
clear(), remove(), put(),
and get() operations must take the appropriate
action on the underlying data structure.  Accessing attributes
via this Map must cause the creation of a session
associated with the current request, if such a session does not
already exist.

For any of the Map methods that cause an element
to be removed from the underlying data structure, the following
action regarding managed-beans must be taken.  If the element to
be removed is a managed-bean, and it has one or more public
no-argument void return methods annotated with
javax.annotation.PreDestroy, each such method must
be called before the element is removed from the underlying data
structure.  Elements that are not managed-beans, but do happen to
have methods with that annotation must not have those methods
called on removal.  Any exception thrown by the
PreDestroy annotated methods must by caught and not
rethrown.  The exception may be logged.

Servlet:  This must be the set of attributes available via
the javax.servlet.http.HttpSession methods
getAttribute(), getAttributeNames(),
removeAttribute(), and setAttribute().

 abstract public Principal getUserPrincipal()
Return the Principal object containing the name of
the current authenticated user, if any; otherwise, return
null.

Servlet: This must be the value returned by the
javax.servlet.http.HttpServletRequest method
getUserPrincipal().

 public  void invalidateSession() 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.invalidateSession();
        } else {
            throw new UnsupportedOperationException();
        }
}

Invalidates this session then unbinds any objects bound to it.

Servlet: This must be the value returned by the javax.servlet.http.HttpSession method invalidate().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public boolean isResponseCommitted() 
{
        if (defaultExternalContext != null) {
            return defaultExternalContext.isResponseCommitted();
        }
        throw new UnsupportedOperationException();
}

Check if the current response has been committed.

Servlet: This must be performed by calling the javax.servlet.http.HttpServletResponse isCommitted method.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 abstract public boolean isUserInRole(String role)
Return true if the currently authenticated user is
included in the specified role.  Otherwise, return false.


Servlet: This must be the value returned by the
javax.servlet.http.HttpServletRequest method
isUserInRole(role).

 abstract public  void log(String message)
Log the specified
message to the application object.

It is valid to call this method
during application startup or shutdown.  If called during application
startup or shutdown, this calls the log() method on the same
container context instance (ServletContext or
PortletContext) as the one used during a call to
log() on the ExternalContext returned
by the FacesContext during an actual request.


Servlet: This must be performed by calling the
javax.servlet.ServletContext method
log(String).

 abstract public  void log(String message,
    Throwable exception)
Log the specified
message and exception to the application object.

It is valid to call this method
during application startup or shutdown.  If called during application
startup or shutdown, this calls the log() method on the same
container context instance (ServletContext or
PortletContext) as the one used when calling
log() on the ExternalContext returned
by the FacesContext during an actual request.

Servlet: This must be performed by calling the
javax.servlet.ServletContext method
log(String,Throwable).

 abstract public  void redirect(String url) throws IOException
Redirect a request 
to the specified URL, and cause the
responseComplete() method to be called on the
FacesContext  instance for the current request.

The implementation must determine if
the request is an Ajax request by obtaining a  
PartialViewContext  instance from the FacesContext  and
calling PartialViewContext#isAjaxRequest() .

Servlet: For
non Ajax requests, this must be accomplished by calling 
the javax.servlet.http.HttpServletResponse method
sendRedirect(). 

For Ajax requests, the implementation must:

Get a PartialResponseWriter  instance from the 
FacesContext .
Call #setResponseContentType  with text/xml
Call #setResponseCharacterEncoding  with UTF-8
Call #addResponseHeader  with Cache-Control, 
no-cache
Call PartialResponseWriter#startDocument 
Call PartialResponseWriter#redirect  with the url
argument.
Call PartialResponseWriter#endDocument 

 public  void responseFlushBuffer() throws IOException 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.responseFlushBuffer();
        } else {
            throw new UnsupportedOperationException();
        }
}

Flushes the buffered response content to the client.

Servlet: This must be performed by calling the javax.servlet.http.HttpServletResponse flushBuffer method.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void responseReset() 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.responseReset();
        } else {
            throw new UnsupportedOperationException();
        }
}

Resets the current response.

Servlet: This must be performed by calling the javax.servlet.http.HttpServletResponse reset method.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void responseSendError(int statusCode,
    String message) throws IOException 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.responseSendError(statusCode, message);
        } else {
            throw new UnsupportedOperationException();
        }
}

Sends an HTTP status code with message.

Servlet: This must be performed by calling the javax.servlet.http.HttpServletResponse sendError method.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void setRequest(Object request) 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.setRequest(request);
        } else {
            throw new UnsupportedOperationException();
        }
}

Set the environment-specific request to be returned by subsequent calls to #getRequest . This may be used to install a wrapper for the request.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void setRequestCharacterEncoding(String encoding) throws UnsupportedEncodingException 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.setRequestCharacterEncoding(encoding);
        } else {
            throw new UnsupportedOperationException();
        }
}

Overrides the name of the character encoding used in the body of this request.

Calling this method after the request has been accessed will have no no effect, unless a Reader or Stream has been obtained from the request, in which case an IllegalStateException is thrown.

Servlet: This must call through to the javax.servlet.ServletRequest method setCharacterEncoding().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void setResponse(Object response) 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.setResponse(response);
        } else {
            throw new UnsupportedOperationException();
        }
}

Set the environment-specific response to be returned by subsequent calls to #getResponse . This may be used to install a wrapper for the response.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void setResponseBufferSize(int size) 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.setResponseBufferSize(size);
        } else {
            throw new UnsupportedOperationException();
        }
}

Set the buffer size for the current response.

Servlet: This must be performed by calling the javax.servlet.http.HttpServletResponse setBufferSize method.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void setResponseCharacterEncoding(String encoding) 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.setResponseCharacterEncoding(encoding);
        } else {
            throw new UnsupportedOperationException();
        }
}

Sets the character encoding (MIME charset) of the response being sent to the client, for example, to UTF-8.

Servlet: This must call through to the javax.servlet.ServletResponse method setCharacterEncoding().

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void setResponseContentLength(int length) 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.setResponseContentLength(length);
        } else {
            throw new UnsupportedOperationException();
        }
}

Set the content length of the response.

Servlet: This must be performed by calling the javax.servlet.http.HttpServletResponse setContentLength method.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void setResponseContentType(String contentType) 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.setResponseContentType(contentType);
        } else {
            throw new UnsupportedOperationException();
        }
}

Sets the content type of the response being sent to the client, if the response has not been committed yet.

Servlet: This must call setContentType() on the underlying javax.servlet.ServletResponse instance.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void setResponseHeader(String name,
    String value) 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.setResponseHeader(name, value);
        } else {
            throw new UnsupportedOperationException();
        }
}

Set the response header with the given name and value.

Servlet:This must be performed by calling the javax.servlet.http.HttpServletResponse setHeader method.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.

 public  void setResponseStatus(int statusCode) 
{
        if (defaultExternalContext != null) {
            defaultExternalContext.setResponseStatus(statusCode);
        } else {
            throw new UnsupportedOperationException();
        }
}

Sets the HTTP status code for the response.

Servlet: This must be performed by calling the javax.servlet.http.HttpServletResponse setStatus method.

The default implementation throws UnsupportedOperationException and is provided for the sole purpose of not breaking existing applications that extend this class.