mojavelinux / CatchExceptionHandler.java

Created December 09, 2010

import java.util.Iterator;
 
import javax.enterprise.inject.spi.BeanManager;
import javax.faces.FacesException;
import javax.faces.context.ExceptionHandler;
import javax.faces.context.ExceptionHandlerWrapper;
import javax.faces.event.AbortProcessingException;
import javax.faces.event.ExceptionQueuedEvent;
 
import org.jboss.seam.exception.control.ExceptionToCatch;
import org.jboss.weld.extensions.core.Requires;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
@Requires("org.jboss.seam.exception.control.extension.CatchExtension")
public class CatchExceptionHandler extends ExceptionHandlerWrapper
{
   private transient Logger log = LoggerFactory.getLogger(CatchExceptionHandler.class);
   
   private ExceptionHandler wrapped;
   private BeanManager beanManager;
   
   // default constructor required to make it a bean
   public CatchExceptionHandler() {}
   
   public CatchExceptionHandler(ExceptionHandler wrapped, BeanManager beanManager)
   {
      this.wrapped = wrapped;
      this.beanManager = beanManager;
   }
   
   @Override
   public void handle() throws FacesException
   {
      Iterator<ExceptionQueuedEvent> it = getUnhandledExceptionQueuedEvents().iterator();
      if (!it.hasNext())
      {
         return;
      }
      
      // example of multiple queued exceptions is two setter methods that failed to update
      // or a failure in both before and after phase of phase listener
      while (it.hasNext())
      {
         Throwable t = it.next().getContext().getException();
         if (!(t instanceof AbortProcessingException))
         {
            ExceptionToCatch catchEvent = new ExceptionToCatch(t);
            beanManager.fireEvent(catchEvent);
            if (catchEvent.isHandled())
            {
               System.out.println("handled");
               it.remove();
            }
         }
      }
      
      if (getUnhandledExceptionQueuedEvents().iterator().hasNext())
      {
         log.debug("Exceptions remain, will be thrown outside of JSF");
         wrapped.handle();
      }
   }
 
   @Override
   public ExceptionHandler getWrapped()
   {
      return wrapped;
   }
}

import javax.enterprise.inject.spi.BeanManager;
import javax.faces.context.ExceptionHandler;
import javax.faces.context.ExceptionHandlerFactory;
 
import org.jboss.weld.extensions.beanManager.BeanManagerAccessor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class CatchExceptionHandlerFactory extends ExceptionHandlerFactory
{
   private transient Logger log = LoggerFactory.getLogger(CatchExceptionHandler.class);
   
   private ExceptionHandlerFactory parent;
   
   private transient boolean catchUnavailable = false;
   
   public CatchExceptionHandlerFactory(ExceptionHandlerFactory parent)
   {
      this.parent = parent;
   }
   
   @Override
   public ExceptionHandler getExceptionHandler()
   {
      log.trace("Creating the JSF exception handler");
      if (catchUnavailable)
      {
         log.trace("Catch integration previously disabled");
         return parent.getExceptionHandler();
      }
      
      BeanManager beanManager = null;
      try
      {
         beanManager = BeanManagerAccessor.getBeanManager();
      }
      catch (IllegalArgumentException e)
      {
         log.info("Could not location BeanManager, Catch integration disabled");
         catchUnavailable = true;
         return parent.getExceptionHandler();
      }
      
      if (beanManager.getBeans(CatchExceptionHandler.class).isEmpty())
      {
         log.info("Catch not available, Catch integration disabled");
         catchUnavailable = true;
         return parent.getExceptionHandler();
      }
      
      log.info("Catch integration enabled");
      return new CatchExceptionHandler(parent.getExceptionHandler(), beanManager);
   }
}