ExceptionHandler (Java EE 6 )

ExceptionHandler is the central point for handling unexpected Exceptions that are thrown during the Faces lifecycle. The ExceptionHandler must not be notified of any Exceptions that occur during application startup or shutdown.

See the specification prose document for the requirements for the default implementation. Exceptions may be passed to the ExceptionHandler in one of two ways:

by ensuring that Exceptions are not caught, or are caught and re-thrown.

This approach allows the ExceptionHandler facility specified in section JSF.6.2 to operate on the Exception.
By using the system event facility to publish an ExceptionQueuedEvent that wraps the Exception.

This approach requires manually publishing the ExceptionQueuedEvent, but allows more information about the Exceptionto be stored in the event. The following code is an example of how to do this.
```
 //...
 } catch (Exception e) {
   FacesContext ctx = FacesContext.getCurrentInstance();
   ExceptionQueuedEventContext eventContext = new ExceptionQueuedEventContext(ctx, e);
   eventContext.getAttributes().put("key", "value");
   ctx.getApplication().publishEvent(ExceptionQueuedEvent.class, eventContext);
 }

 
```
Because the Exception must not be re-thrown when using this approach, lifecycle processing may continue as normal, allowing more Exceptions to be published if necessary.

With either approach, any ExceptionQueuedEvent instances that are published in this way are accessible to the handle() method, which is called at the end of each lifecycle phase, as specified in section JSF.6.2.

Instances of this class are request scoped and are created by virtue of FacesContextFactory#getFacesContext calling ExceptionHandlerFactory#getExceptionHandler.

Method Summary
`abstract ExceptionQueuedEvent`	`getHandledExceptionQueuedEvent()` Return the first `ExceptionQueuedEvent` handled by this handler.
`abstract java.lang.Iterable<ExceptionQueuedEvent>`	`getHandledExceptionQueuedEvents()` The default implementation must return an `Iterable` over all `ExceptionQueuedEvent`s that have been handled by the `handle()` method.
`abstract java.lang.Throwable`	`getRootCause(java.lang.Throwable t)` Unwrap the argument `t` until the unwrapping encounters an Object whose `getClass()` is not equal to `FacesException.class` or `javax.el.ELException.class`.
`abstract java.lang.Iterable<ExceptionQueuedEvent>`	`getUnhandledExceptionQueuedEvents()` Return an `Iterable` over all `ExceptionQueuedEvent`s that have not yet been handled by the `handle()` method.
`abstract void`	`handle()` Take action to handle the `Exception` instances residing inside the `ExceptionQueuedEvent` instances that have been queued by calls to `Application().publishEvent(ExceptionQueuedEvent.class, eventContext)`.
`abstract boolean`	`isListenerForSource(java.lang.Object source)` This method must return `true` if and only if this listener instance is interested in receiving events from the instance referenced by the `source` parameter.
`abstract void`	`processEvent(SystemEvent exceptionQueuedEvent)` When called, the listener can assume that any guarantees given in the javadoc for the specific `SystemEvent` subclass are true.

javax.faces.context Class ExceptionHandler

ExceptionHandler

handle

getHandledExceptionQueuedEvent

getUnhandledExceptionQueuedEvents

getHandledExceptionQueuedEvents

processEvent

isListenerForSource

getRootCause

javax.faces.context
Class ExceptionHandler