public class EJBExceptionHandler implements AroundAdvice {

   private ExceptionHandler handler;

   public EJBExceptionHandler() {
      handler = ConfigHelper.getEJBExceptionHandler();
   }

   public Object invoke(JoinPoint joinPoint) throws Throwable {

      Log log = LogFactory.getLog(joinPoint.getEnclosingStaticJoinPoint().getClass().getName());
      log.debug("EJB Exception Handler bean context aspect!!");
      try {
         return joinPoint.proceed();
      } catch (RuntimeException e) {
         handler.handle(Thread.currentThread(), e);
      } catch (Error e) {
         handler.handle(Thread.currentThread(), e);
      }
      return null;
   }
}

public java.lang.String someOtherMethod()  {
   try {
      return serviceInterface.someOtherMethod();
   } catch (EJBException e) {
      BusinessDelegateUtil.throwActualException(e);
   }
   return null; // Statement is never reached
}

public static void throwActualException(EJBException e) {
   doThrowActualException(e);
}

private static void doThrowActualException(Throwable actual) {
   boolean done = false;
   while(!done) {
      if(actual instanceof RemoteException) {
         actual = ((RemoteException)actual).detail;
      } else if (actual instanceof EJBException) {
         actual = ((EJBException)actual).getCausedByException();
      } else {
         done = true;
      }
   }
   if(actual instanceof RuntimeException) {
      throw (RuntimeException)actual;
   } else if (actual instanceof Error) {
      throw (Error)actual;
   }
}

private static class SwingThreadGroup extends ThreadGroup {

   private ExceptionHandler handler;

   public SwingThreadGroup(ExceptionHandler handler) {
      super("Swing ThreadGroup");
      this.handler = handler;
   }

   public void uncaughtException(Thread t, Throwable e) {
      handler.handle(t, e);
   }
}

public DemoApp() {
  
   SwingExceptionHandlerController.setHandler(new DefaultSwingExceptionHandler());
   SwingExceptionHandlerController.setMain(new SwingMain() {

      public Component getParentComponent() {
         return frame;
      }

      public void run() {
         createAndShowGUI();
      }
   });

   SwingExceptionHandlerController.start();
   SwingExceptionHandlerController.join();
}

<servlet>
   <servlet-name>ErrorHandlerServlet</servlet-name>
   <servlet-class>dk.rhos.fw.rampart.util.errorhandling.ErrorHandlerServlet</servlet-class>
</servlet>

<servlet-mapping>
   <servlet-name>ErrorHandlerServlet</servlet-name>
   <url-pattern>/errorhandler</url-pattern>
</servlet-mapping>

<error-page>
   <exception-type>java.lang.Throwable</exception-type>
   <location>/errorhandler</location>
</error-page>

...
private static final String CONST_EXCEPTION = "javax.servlet.error.exception";
...

protected void service(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) 
   throws ServletException, IOException 
{

   Throwable exception = (Throwable)httpServletRequest.getAttribute(CONST_EXCEPTION);

   ExceptionHandler handler = ConfigHelper.getWARExceptionHandler();
   handler.handle(Thread.currentThread(), exception);

   String responsePage = (String)ConfigHelper.getRequestContextFactory().
      getRequestContext().
      getAttribute(ExceptionConstants.CONST_RESPONSEPAGE);

   if(responsePage == null) {
      responsePage = "/error.jsp";
   }

   httpServletResponse.setStatus(HttpServletResponse.SC_OK);

   RequestDispatcher dispatcher = httpServletRequest.getRequestDispatcher(responsePage);
   try {
      dispatcher.include(httpServletRequest, httpServletResponse);
   } catch (Exception e) {
      log.error("Failed to dispatch error to responsePage " + responsePage, e);
   }
}