Search This Blog

Tuesday, September 21, 2010

JSF 2 Exception Handling

JSF 2 introduced ExceptionHandler as central point for handling unexpected Exceptions that are thrown during the Faces lifecycle.

To avoid silent exceptions that are not catched in application implement your ExceptionHandler and do what ever you want with exception.

1. Create your implementation of ExceptionHandler:
public class MyExceptionHandler extends ExceptionHandlerWrapper {

  private static Log log = LogFactory.getLog(MyExceptionHandler.class);
  private ExceptionHandler wrapped;

  public MyExceptionHandler(ExceptionHandler wrapped) {
    this.wrapped = wrapped;

  public ExceptionHandler getWrapped() {
    return wrapped;

  public void handle() throws FacesException {
    //Iterate over all unhandeled exceptions
    Iterator i = getUnhandledExceptionQueuedEvents().iterator();
    while (i.hasNext()) {
      ExceptionQueuedEvent event =;
      ExceptionQueuedEventContext context =

      //obtain throwable object
      Throwable t = context.getException();

      //here you do what ever you want with exception
      //log error
        log.error("Serious error happened!", t);
        //redirect to error view etc....  
        //after exception is handeled, remove it from queue
    //let the parent handle the rest
2. Create your ExceptionHandlerFactory and call your ExceptionHandler:
public class MyExceptionHandlerFactory extends ExceptionHandlerFactory {

  private ExceptionHandlerFactory parent;

  // this injection handles jsf
  public MyExceptionHandlerFactory(ExceptionHandlerFactory parent) {
    this.parent = parent;

  //create your own ExceptionHandler
  public ExceptionHandler getExceptionHandler() {
    ExceptionHandler result =
        new MyExceptionHandler(parent.getExceptionHandler());
    return result;
3. Register your exception handler factory in faces-config.xml:

Wednesday, September 15, 2010

Java heap dump

I recently worked on a project where I was faced with "out of memory" problem. Exception appeared usually after the application has worked for several weeks. I solved the problem with VisualVM tool that ships with Java 1.6 JDK.
VisualVM tool provides a direct connection to any Virtual Machine locally or remote, or can load heap dump or thread dump from a file.

To dump heap memory to a file type in console(linux):
  1. Get java process id
    ps -eaf | grep java
  2. Dump heap memory to a file using jmap ("jmap prints shared object memory maps or heap memory details of a given process or core file or a remote debug server")
    jmap -heap:format=b PID (where PID i id of your java process)
  3. Run jvisualvm
    jvisualvm -J-Xmx512M
  4. Load heap.bin file
  5. Find biggest objects by retained size. After file loads you can see every object that was in memory at the time the dump was taken.Click on find biggest objects by retained size and you will get hierarchy of biggest objects in memory.
In this way, I discovered that I have HashMap object in some other singleton object, and the values were added to map, but never removed.