javax.faces.context.FacesContext Maven / Gradle / Ivy
Show all versions of jsf-api Show documentation
/*
* 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.context;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.faces.application.Application;
import javax.faces.application.FacesMessage;
import javax.faces.application.ProjectStage;
import javax.faces.application.FacesMessage.Severity;
import javax.faces.component.UIViewRoot;
import javax.faces.render.RenderKit;
import javax.el.ELContext;
import javax.faces.FactoryFinder;
import javax.faces.component.UINamingContainer;
import javax.faces.event.PhaseId;
/**
* FacesContext contains all of the
* per-request state information related to the processing of a single
* JavaServer Faces request, and the rendering of the corresponding
* response. It is passed to, and potentially modified by, each phase
* of the request processing lifecycle.
*
* A {@link FacesContext} instance is associated with a particular
* request at the beginning of request processing, by a call to the
* getFacesContext() method of the {@link FacesContextFactory}
* instance associated with the current web application. The instance
* remains active until its release() method is called, after
* which no further references to this instance are allowed. While a
* {@link FacesContext} instance is active, it must not be referenced
* from any thread other than the one upon which the servlet container
* executing this web application utilizes for the processing of this request.
*
*/
public abstract class FacesContext {
@SuppressWarnings({"UnusedDeclaration"})
private FacesContext defaultFacesContext;
private boolean processingEvents = true;
private boolean isCreatedFromValidFactory = true;
private static ConcurrentHashMap threadInitContext = new ConcurrentHashMap(2);
private static ConcurrentHashMap initContextServletContext = new ConcurrentHashMap(2);
public FacesContext() {
Thread curThread = Thread.currentThread();
StackTraceElement[] callstack = curThread.getStackTrace();
if (null != callstack) {
String declaringClassName = callstack[3].getClassName();
try {
ClassLoader curLoader = curThread.getContextClassLoader();
Class declaringClass = curLoader.loadClass(declaringClassName);
if (!FacesContextFactory.class.isAssignableFrom(declaringClass)) {
isCreatedFromValidFactory = false;
}
} catch (ClassNotFoundException cnfe) {
}
}
}
// -------------------------------------------------------------- Properties
/**
* Return the {@link
* Application} instance associated with this web application.
* It is valid to call this method
* during application startup or shutdown. If called during application
* startup or shutdown, returns the correct current {@link
* javax.faces.application.Application} instance.
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract Application getApplication();
/**
* Return a mutable Map
* representing the attributes associated wth this
* FacesContext instance. This Map is
* useful to store attributes that you want to go out of scope when the
* Faces lifecycle for the current request ends, which is not always the same
* as the request ending, especially in the case of Servlet filters
* that are invoked after the Faces lifecycle for this
* request completes. Accessing this Map does not cause any
* events to fire, as is the case with the other maps: for request, session, and
* application scope. When {@link #release()} is invoked, the attributes
* must be cleared.
*
*
*
* The Map returned by this method is not associated with
* the request. If you would like to get or set request attributes,
* see {@link ExternalContext#getRequestMap}.
*
*
The default implementation throws
* UnsupportedOperationException and is provided
* for the sole purpose of not breaking existing applications that extend
* this class.
*
*
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*
* @since 2.0
*/
public Map getAttributes() {
if (defaultFacesContext != null) {
return defaultFacesContext.getAttributes();
}
if (!isCreatedFromValidFactory) {
if (attributesForInvalidFactoryConstruction == null) {
attributesForInvalidFactoryConstruction = new HashMap();
}
return attributesForInvalidFactoryConstruction;
}
throw new UnsupportedOperationException();
}
private Map attributesForInvalidFactoryConstruction;
/**
* Return the {@link PartialViewContext}
* for this request. The {@link PartialViewContext} is used to control
* the processing of specified components during the execute portion of
* the request processing lifecycle (known as partial processing) and
* the rendering of specified components (known as partial rendering).
* This method must return a new {@link PartialViewContext} if one
* does not already exist.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*
* @since 2.0
*/
public PartialViewContext getPartialViewContext() {
if (defaultFacesContext != null) {
return defaultFacesContext.getPartialViewContext();
}
if (!isCreatedFromValidFactory) {
if (partialViewContextForInvalidFactoryConstruction == null) {
PartialViewContextFactory f = (PartialViewContextFactory)
FactoryFinder.getFactory(FactoryFinder.PARTIAL_VIEW_CONTEXT_FACTORY);
partialViewContextForInvalidFactoryConstruction = f.getPartialViewContext(this);
}
return partialViewContextForInvalidFactoryConstruction;
}
throw new UnsupportedOperationException();
}
private PartialViewContext partialViewContextForInvalidFactoryConstruction = null;
/**
* Return an Iterator over the client identifiers for
* which at least one {@link javax.faces.application.FacesMessage} has been queued. If there are no
* such client identifiers, an empty Iterator is returned.
* If any messages have been queued that were not associated with any
* specific client identifier, a null value will be included
* in the iterated values. The elements in the Iterator must
* be returned in the order in which they were added with {@link #addMessage}.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract Iterator getClientIdsWithMessages();
/**
* Return the ELContext instance for this
* FacesContext instance. This ELContext
* instance has the same lifetime and scope as the
* FacesContext instance with which it is associated,
* and may be created lazily the first time this method is called
* for a given FacesContext instance. Upon creation of
* the ELContext instance, the implementation must take the
* following action:
*
*
*
* Call the {@link ELContext#putContext} method on the
* instance, passing in FacesContext.class and the
* this reference for the FacesContext
* instance itself.
If the Collection returned by {@link
* javax.faces.application.Application#getELContextListeners} is
* non-empty, create an instance of {@link
* javax.el.ELContextEvent} and pass it to each {@link
* javax.el.ELContextListener} instance in the
* Collection by calling the {@link
* javax.el.ELContextListener#contextCreated} method.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*
* @since 1.2
*/
public ELContext getELContext() {
if (defaultFacesContext != null) {
return defaultFacesContext.getELContext();
}
throw new UnsupportedOperationException();
}
/**
* Return the {@link ExceptionHandler}
* for this request.
*/
public ExceptionHandler getExceptionHandler() {
if (defaultFacesContext != null) {
return defaultFacesContext.getExceptionHandler();
}
throw new UnsupportedOperationException();
}
/**
* Set the {@link ExceptionHandler} for
* this request.
*
* @param exceptionHandler the ExceptionHandler for
* this request.
*/
public void setExceptionHandler(ExceptionHandler exceptionHandler) {
if (defaultFacesContext != null) {
defaultFacesContext.setExceptionHandler(exceptionHandler);
} else {
throw new UnsupportedOperationException();
}
}
/**
* Return the {@link
* ExternalContext} instance for this FacesContext
* instance.
* It is valid to call this method
* during application startup or shutdown. If called during application
* startup or shutdown, this method returns an {@link ExternalContext} instance
* with the special behaviors indicated in the javadoc for that
* class. Methods document as being valid to call during
* application startup or shutdown must be supported.
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract ExternalContext getExternalContext();
/**
* Return the maximum severity level recorded on any
* {@link javax.faces.application.FacesMessage}s that has been queued, whether or not they are
* associated with any specific {@link javax.faces.component.UIComponent}. If no such messages
* have been queued, return null.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract Severity getMaximumSeverity();
/**
* Return an Iterator over the {@link javax.faces.application.FacesMessage}s
* that have been queued, whether or not they are associated with any
* specific client identifier. If no such messages have been queued,
* return an empty Iterator. The elements of the Iterator
* must be returned in the order in which they were added with calls to {@link
* #addMessage}.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract Iterator getMessages();
/**
* Like {@link #getMessages}, but
* returns a List<FacesMessage>,
* enabling use from EL expressions.
*
* The default implementation throws
* UnsupportedOperationException and is provided
* for the sole purpose of not breaking existing applications that extend
* this class.
*
* @return an immutable List which is effectively a snapshot
* of the messages present at the time of invocation.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*
* @since 2.0
*/
public List getMessageList() {
if (defaultFacesContext != null) {
return defaultFacesContext.getMessageList();
}
throw new UnsupportedOperationException();
}
/**
* Like {@link
* #getMessages(java.lang.String)}, but returns a
* List<FacesMessage> of messages for the
* component with client id matching argument
* clientId.
*
* The default implementation throws
* UnsupportedOperationException and is provided
* for the sole purpose of not breaking existing applications that extend
* this class.
*
* @return an immutable List which is effectively a snapshot
* of the messages present at the time of invocation.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*
* @since 2.0
*/
public List getMessageList(String clientId) {
if (defaultFacesContext != null) {
return defaultFacesContext.getMessageList(clientId);
}
throw new UnsupportedOperationException();
}
/**
* Return an Iterator over the {@link javax.faces.application.FacesMessage}s that
* have been queued that are associated with the specified client identifier
* (if clientId is not null), or over the
* {@link javax.faces.application.FacesMessage}s that have been queued that are not associated with
* any specific client identifier (if clientId is
* null). If no such messages have been queued, return an
* empty Iterator. The elements of the Iterator
* must be returned in the order in which they were added with calls to {@link
* #addMessage}.
*
* @param clientId The client identifier for which messages are
* requested, or null for messages not associated with
* any client identifier
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract Iterator getMessages(String clientId);
/**
* Return the result of calling {@link
* UINamingContainer#getSeparatorChar}, passing this as
* the argument. Note that this enables accessing the value of this
* property from the EL expression
* #{facesContext.namingContainerSeparatorChar}.
*/
public char getNamingContainerSeparatorChar() {
return UINamingContainer.getSeparatorChar(this);
}
/**
* Return the {@link RenderKit} instance for the render kit identifier
* specified on our {@link UIViewRoot}, if there is one. If there is no
* current {@link UIViewRoot}, if the {@link UIViewRoot} does not have a
* specified renderKitId, or if there is no {@link RenderKit}
* for the specified identifier, return null instead.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract RenderKit getRenderKit();
/**
* Return true if the renderResponse()
* method has been called for the current request.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract boolean getRenderResponse();
/**
* Return true if the responseComplete()
* method has been called for the current request.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract boolean getResponseComplete();
/**
* Return the list of resource library
* contracts that have been calculated
* to be appropriate for use with this view, or an empty list if there are
* no such resource library contracts. The list returned by this method
* must be immutable. For backward compatibility with implementations
* of the specification prior to when this method was introduced, an
* implementation is provided that returns an empty list. Implementations
* compliant with the version in which this method was introduced must
* implement this method as specified.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*
* @since 2.2
*/
public List getResourceLibraryContracts() {
return Collections.emptyList();
}
/**
* Set the resource library contracts
* calculated as valid to use with this view. The implementation must
* copy the contents of the incoming {@code List} into an immutable
* {@code List} for return from {@link #getResourceLibraryContracts}.
* If the argument is {@code null} or empty, the action taken is the same as if
* the argument is {@code null}: a subsequent call to {@code getResourceLibraryContracts}
* returns {@code null}. This method may only be called during the
* processing of {@link javax.faces.view.ViewDeclarationLanguage#createView}
* and during the VDL tag handler for the tag corresponding to
* an instance of {@code UIViewRoot}. For backward compatibility with implementations
* of the specification prior to when this method was introduced, an
* implementation is provided that takes no action. Implementations
* compliant with the version in which this method was introduced must
* implement this method as specified.
*
*
*
* @param contracts The new contracts to be returned, as an immutable
* {@code List}. from a subsequent call to {@link #getResourceLibraryContracts}.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*
*/
public void setResourceLibraryContracts(List contracts) {
}
/**
* Return true if the validationFailed()
* method has been called for the current request.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public boolean isValidationFailed() {
if (defaultFacesContext != null) {
return defaultFacesContext.isValidationFailed();
}
throw new UnsupportedOperationException();
}
/**
* Return the {@link ResponseStream} to which components should
* direct their binary output. Within a given response, components
* can use either the ResponseStream or the ResponseWriter,
* but not both.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract ResponseStream getResponseStream();
/**
*
Set the {@link ResponseStream} to which components should
* direct their binary output.
*
* @param responseStream The new ResponseStream for this response
*
* @throws NullPointerException if responseStream
* is null
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract void setResponseStream(ResponseStream responseStream);
/**
*
Return the {@link ResponseWriter} to which components should
* direct their character-based output. Within a given response,
* components can use either the ResponseStream or the ResponseWriter,
* but not both.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract ResponseWriter getResponseWriter();
/**
* Set the {@link ResponseWriter} to which components should
* direct their character-based output.
*
* @param responseWriter The new ResponseWriter for this response
*
* @throws IllegalStateException if this method is called after
* this instance has been released
* @throws NullPointerException if responseWriter
* is null
*/
public abstract void setResponseWriter(ResponseWriter responseWriter);
/**
*
Return the root
* component that is associated with the this request.
* It is valid to call this method
* during application startup or shutdown. If called during application
* startup or shutdown, this method returns a new UIViewRoot with
* its locale set to Locale.getDefault().
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract UIViewRoot getViewRoot();
/**
* Set the root component that is
* associated with this request.
*
This method can be called by the
* application handler (or a class that the handler calls), during
* the Invoke Application phase of the request processing
* lifecycle and during the Restore View phase of the
* request processing lifecycle (especially when a new root
* component is created). In the present version of the
* specification, implementations are not required to enforce this
* restriction, though a future version of the specification may
* require enforcement.
* If the current
* UIViewRoot is non-null, and calling
* equals() on the argument root, passing
* the current UIViewRoot returns false,
* the clear method must be called on the
* Map returned from {@link UIViewRoot#getViewMap}.
*
* @param root The new component {@link UIViewRoot} component
*
* @throws IllegalStateException if this method is called after
* this instance has been released
* @throws NullPointerException if root
* is null
*/
public abstract void setViewRoot(UIViewRoot root);
// ---------------------------------------------------------- Public Methods
/**
* Append a {@link javax.faces.application.FacesMessage} to the set of messages associated with
* the specified client identifier, if clientId is
* not null. If clientId is null,
* this {@link javax.faces.application.FacesMessage} is assumed to not be associated with any
* specific component instance.
*
* @param clientId The client identifier with which this message is
* associated (if any)
* @param message The message to be appended
*
* @throws IllegalStateException if this method is called after
* this instance has been released
* @throws NullPointerException if message
* is null
*/
public abstract void addMessage(String clientId, FacesMessage message);
/**
*
* Return a flag indicating if the resources associated with this
* FacesContext instance have been released.
* @return true if the resources have been released.
*
* @since 2.1
*/
public boolean isReleased() {
if (defaultFacesContext != null) {
return defaultFacesContext.isReleased();
}
throw new UnsupportedOperationException();
}
/**
* Release any
* resources associated with this FacesContext
* instance. Faces implementations may choose to pool instances in
* the associated {@link FacesContextFactory} to avoid repeated
* object creation and garbage collection. After
* release() is called on a FacesContext
* instance (until the FacesContext instance has been
* recycled by the implementation for re-use), calling any other
* methods will cause an IllegalStateException to be
* thrown.
* If a call was made to {@link
* #getAttributes} during the processing for this request, the
* implementation must call clear() on the
* Map returned from getAttributes(), and
* then de-allocate the data-structure behind that
* Map.
* The implementation must call {@link #setCurrentInstance}
* passing null to remove the association between this
* thread and this dead FacesContext instance.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract void release();
/**
* Signal the JavaServer faces implementation that, as soon as the
* current phase of the request processing lifecycle has been completed,
* control should be passed to the Render Response phase,
* bypassing any phases that have not been executed yet.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract void renderResponse();
/**
*
* This utility method simply returns the result of
* {@link javax.faces.render.ResponseStateManager#isPostback(FacesContext)}.
*
*
* The default implementation throws
* UnsupportedOperationException and is provided
* for the sole purpose of not breaking existing applications that extend
* this class.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*
* @since 2.0
*/
public boolean isPostback() {
if (defaultFacesContext != null) {
return defaultFacesContext.isPostback();
}
throw new UnsupportedOperationException();
}
/**
* Signal the JavaServer Faces implementation that the HTTP response
* for this request has already been generated (such as an HTTP redirect),
* and that the request processing lifecycle should be terminated as soon
* as the current phase is completed.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public abstract void responseComplete();
/**
* Sets a flag which indicates that a conversion or
* validation error occurred while processing the inputs. Inputs consist of
* either page parameters or form bindings. This flag can be read using
* {@link #isValidationFailed}.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*/
public void validationFailed() {
if (defaultFacesContext != null) {
defaultFacesContext.validationFailed();
} else {
throw new UnsupportedOperationException();
}
}
/**
* Return the value last set on this
* FacesContext instance when {@link #setCurrentPhaseId}
* was called.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*
* @since 2.0
*/
public PhaseId getCurrentPhaseId() {
if (defaultFacesContext != null) {
return defaultFacesContext.getCurrentPhaseId();
}
if (!isCreatedFromValidFactory) {
return this.currentPhaseIdForInvalidFactoryConstruction;
}
throw new UnsupportedOperationException();
}
/**
* The implementation must call this method
* at the earliest possble point in time after entering into a new phase
* in the request processing lifecycle.
*
* @param currentPhaseId The {@link javax.faces.event.PhaseId} for the
* current phase.
*
* @throws IllegalStateException if this method is called after
* this instance has been released
*
* @since 2.0
*/
public void setCurrentPhaseId(PhaseId currentPhaseId) {
if (defaultFacesContext != null) {
defaultFacesContext.setCurrentPhaseId(currentPhaseId);
} else if (!isCreatedFromValidFactory) {
this.currentPhaseIdForInvalidFactoryConstruction = currentPhaseId;
} else {
throw new UnsupportedOperationException();
}
}
private PhaseId currentPhaseIdForInvalidFactoryConstruction;
/**
* Allows control of wheter or not the runtime
* will publish events when {@link Application#publishEvent(FacesContext, Class, Object)} or
* {@link Application#publishEvent(FacesContext, Class, Class, Object)} is called.
*
* @param processingEvents flag indicating events should be processed or not
*/
public void setProcessingEvents(boolean processingEvents) {
this.processingEvents = processingEvents;
}
/**
* Returns a flag indicating whether or
* not the runtime should publish events when asked to do so.
* @return true if events should be published, otherwise
* false
*/
public boolean isProcessingEvents() {
return this.processingEvents;
}
/**
* Return true if the
* current {@link ProjectStage} as returned by the {@link
* Application} instance is equal to stage, otherwise
* return false
* @param stage the {@link ProjectStage} to check
*
* @throws IllegalStateException if this method is called after
* this instance has been released
* @throws NullPointerException if stage is null
*/
public boolean isProjectStage(ProjectStage stage) {
if (stage == null) {
throw new NullPointerException();
}
return (stage.equals(getApplication().getProjectStage()));
}
// ---------------------------------------------------------- Static Methods
/**
* The ThreadLocal variable used to record the
* {@link FacesContext} instance for each processing thread.
*/
private static ThreadLocal instance = new ThreadLocal() {
protected FacesContext initialValue() { return (null); }
};
/**
* Return the {@link FacesContext}
* instance for the request that is being processed by the current
* thread. If called during application initialization or shutdown,
* any method documented as "valid to call this method during
* application startup or shutdown" must be supported during
* application startup or shutdown time. The result of calling a
* method during application startup or shutdown time that does not
* have this designation is undefined.
*/
public static FacesContext getCurrentInstance() {
FacesContext facesContext = instance.get();
if (null == facesContext) {
facesContext = (FacesContext)threadInitContext.get(Thread.currentThread());
}
return facesContext;
}
/**
* Set the {@link FacesContext} instance for the request that is
* being processed by the current thread.
*
* @param context The {@link FacesContext} instance for the current
* thread, or null if this thread no longer has a
* FacesContext instance.
*
*/
protected static void setCurrentInstance(FacesContext context) {
if (context == null) {
instance.remove();
} else {
instance.set(context);
}
}
}