Durante la ejecución de una aplicación se pueden producir excepciones en el servidor por diversas causas, un problema de acceso a la base de datos, un error de programación, etc. En el caso de JSF 2, durante las peticiones HTTP, se delega en el sistema que ofrece el contenedor de servlets para el tratamiento de las excepciones. Mediante la definición de reglas del tipo <error-page> en el web.xml de la aplicación podemos conseguir que ante determinadas excepciones del servidor se redirija la petición a una página de error concreta.
JSF 2 además nos ofrece la posibilidad de hilar más fino mediante un ExceptionHandler. La extensión de las clases ExceptionHandlerWrapper y ExceptionHandlerFactory nos permite capturar las excepciones que salten durante la ejecución del ciclo de vida de JSF y hacer un tratamiento concreto dependiendo de la excepción producida.
Este mecanismo es muy útil para el tratamiento de excepciones dentro de llamadas AJAX en una aplicación JSF, puesto que tanto Mojarra como MyFaces ignoran por defecto este tipo de excepciones con las configuraciones de producción, con lo que el usuario no es consciente de que ha ocurrido un error grave en la aplicación.
Vamos a ver como podríamos solucionar este problema con un ejemplo sencillo en el que vamos a redirigir a una página determinada en caso de encontrarnos con una excepción durante una petición AJAX.
Por un lado declaramos nuestra factoría de ExceptionHandler:
public class AjaxExceptionHandlerFactory extends ExceptionHandlerFactory {
/**
* wrapped
*/
private ExceptionHandlerFactory wrapped;
/**
* Constructor de una factoria para el manejo de excepciones AJAX.
*
* @param wrapped La factoría que se encapsula.
*/
public AjaxExceptionHandlerFactory(ExceptionHandlerFactory wrapped) {
this.wrapped = wrapped;
}
/**
* Devuelve una nueva instancia de AjaxExceptionHandler que
* envuelve el exception handler original.
* @return ExceptionHandler ExceptionHandler
*/
@Override
public ExceptionHandler getExceptionHandler() {
return new AjaxExceptionHandler(
getWrapped().getExceptionHandler());
}
/**
* Devuelve la factoría encapsulada.
* @return ExceptionHandlerFactory ExceptionHandlerFactory
*/
@Override
public ExceptionHandlerFactory getWrapped() {
return wrapped;
}
}
A continuación nuestro ExceptionHandler:
public class AjaxExceptionHandler extends ExceptionHandlerWrapper { /** * Logger. */ public static final Log LOG = LogFactory.getLog(AjaxExceptionHandler.class); /** * Exception handler encapsulado */ private ExceptionHandler wrapped; /** * Constructos de un nuevo exception handler para peticiones * ajax encapsulando el exception handler indicado. * * @param wrapped El exception handler encapsulado. */ public AjaxExceptionHandler(ExceptionHandler wrapped) { this.wrapped = wrapped; } /** * Maneja las excepciones en peticiones ajax de la siguiente manera, * sólo y sólo si la actual petición es una petición ajax cuya * respuesta aún no ha sido enviada y existe al menos una excepción * que no ha sido tratada. * * Las demás excepciones pendientes serán ignoradas, primero hay que * corregir la primera. */ @Override public void handle() { handleAjaxException(getContext()); wrapped.handle(); } @Override public ExceptionHandler getWrapped() { return wrapped; } /** * Metodo que devuelve el contexto JSF * @return Contexto JSF actual */ private static FacesContext getContext() { return FacesContext.getCurrentInstance(); } /** * Método que se encarga de tratar las excepciones encontradas * durante una petición JSF. Sólo se van a tratar las excepciones en * peticiones ajax. Si la excepción es en una petición HTTP normal ya * se encarga el web.xml de redirigir a la página de error. * * @param context Contexto JSF actual. */ private void handleAjaxException(FacesContext context) { if (context == null || !context.getPartialViewContext().isAjaxRequest()) { return; // No es una request ajax } Iterator<ExceptionQueuedEvent> unhandledExcQueuedEvents = getUnhandledExceptionQueuedEvents() .iterator(); if (!unhandledExcQueuedEvents.hasNext()) { return; // No hay excepciones pendientes. } Throwable exception = unhandledExcQueuedEvents.next() .getContext().getException(); if (exception instanceof AbortProcessingException) { return; // Let JSF handle it itself. } exception = findExceptionRootCause(exception); String errorPageLocation = "/errorPage.xhtml"; unhandledExcQueuedEvents.remove(); ExternalContext externalContext = context.getExternalContext(); LOG.error(String.format( "Ocurrio un error no esperado, redirigiendo a %s", errorPageLocation), exception); // Añadimos información sobre la excepcion al request HTTP para //que pueda ser mostrada en la pagina de error HttpServletRequest request = (HttpServletRequest) externalContext.getRequest(); request.setAttribute(ERROR_EXCEPTION, exception); request.setAttribute(ERROR_EXCEPTION_TYPE, exception.getClass()); request.setAttribute(ERROR_MESSAGE, exception.getMessage()); request.setAttribute(ERROR_REQUEST_URI, request.getRequestURI()); request.setAttribute(ERROR_STATUS_CODE, HttpServletResponse.SC_INTERNAL_SERVER_ERROR); try { renderErrorPageView(context, request, errorPageLocation); } catch (IOException e) { throw new FacesException(e); } while (unhandledExcQueuedEvents.hasNext()) { // No nos interesan el resto de excepciones, sólo la primera. unhandledExcQueuedEvents.next(); unhandledExcQueuedEvents.remove(); } } /** * Determina la raiz de la causa de una excepción. * * @param exception La excepción de la que se quiere encontrar * la raiz de la causa. * @return La excepción raiz de la causa de la excepción primera. */ private Throwable findExceptionRootCause(Throwable exception) { return unwrap(exception); } /** * Desenvuelve las causas anidadas de una determinada excepción * mientras no se encuentre una instancia del tipo indicado, * entonces se devuelve dicha instancia. * * @param <T> El tipo genérico throwable. * @param exception La excepción a desenvolver. * @param type El tipo de excepción que tiene que ser devuelto. * @return La raiz de la causa de la excepción inicial. */ private static <T extends Throwable> Throwable unwrap( Throwable exception, Class<T> type) { while (type.isInstance(exception) && exception.getCause() != null) { exception = exception.getCause(); } return exception; } /** * Devuelve las causas anidadas de una excepción dada mientras no * sean instancias de FacesException (Mojarra) o * ELException (MyFaces). * * @param exception La excepción de la que se quiere quitar el * anidamiento con FacesException y ELException. * @return La causa de la excepción. */ private static Throwable unwrap(Throwable exception) { return unwrap( unwrap(exception, FacesException.class), ELException.class); } /** * Muestra la página de error indicada. * * @param context Contexto JSF actual * @param request Request de la petición actual * @param errorPageLocation Localización de la página * de error a mostrar. * @throws IOException En caso de que ocurra un error * mostrando la página de error, y no se * pueda mostrar la página de error de emergencia. */ private void renderErrorPageView(FacesContext context, final HttpServletRequest request, String errorPageLocation) throws IOException { String viewId = errorPageLocation; ViewHandler viewHandler = context .getApplication().getViewHandler(); UIViewRoot viewRoot = viewHandler.createView(context, viewId); context.setViewRoot(viewRoot); context.getPartialViewContext().setRenderAll(true); try { ViewDeclarationLanguage vdl = viewHandler.getViewDeclarationLanguage(context, viewId); vdl.buildView(context, viewRoot); context.getApplication().publishEvent( context,PreRenderViewEvent.class, viewRoot); vdl.renderView(context, viewRoot); context.responseComplete(); } catch (Exception e) { // Aqui podríamos mostrar una página de error // estática si todo ha ido mal throw new FacesException(e); } finally { // Evitamos que el contenedor de la aplicación // trate de manejar esta excepción. request.removeAttribute(ERROR_EXCEPTION); } }}
Por último declaramos nuestra factoría en el faces-config.xml de nuestra aplicación:
<factory>
<exception-handler-factory>
org.exceptionhandler.AjaxExceptionHandlerFactory
</exception-handler-factory>
</factory>
Esta solución está basada en la propuesta por la librería Omnifaces. Consutar en las referencias la documentación del FullAjaxExceptionHandler de Omnifaces para una implementación más completa y con ajustes para una mejor integración con distintos frameworks JSF.
Más información:
https://docs.oracle.com/javaee/6/api/javax/faces/context/ExceptionHandler.html
http://showcase.omnifaces.org/exceptionhandlers/FullAjaxExceptionHandler
http://balusc.blogspot.com.es/2012/03/full-ajax-exception-handler.html
https://weblogs.java.net/blog/edburns/archive/2009/09/03/dealing-gracefully-viewexpiredexception-jsf2
http://www.beyondjava.net/blog/jsf-2-0-hides-exceptions-ajax/
No hay comentarios:
Publicar un comentario