Java Global Exception Handler

1. Overview

In this tutorial, we’ll focus on the Global Exception Handler in Java. We’ll first discuss the basics of the exceptions and the exception handling. Then we’ll have a comprehensive look on the global exception handler.

To learn more about the exceptions in general, have a look at Exception Handling in Java.

2. What Is an Exception?

An exception is an abnormal condition that arises in a code sequence at runtime or at compile time. This abnormal condition arises when a program violates the semantic constraints of the Java programming language.

Exceptions that occur during the compile time are checked exceptions. These exceptions are direct subclasses of the Exception class, and it’s necessary to handle these exceptions in the code.

Another type of exceptions are the unchecked exceptions. The compiler does not check for these exceptions during the compile time. These exceptions are direct subclasses of the RuntimeException class which extends the Exception class.

Also, it’s not necessary to handle runtime exceptions in the code.

3. Exception Handlers

Java is a robust programming language. One of the core features that makes it robust is the exception handling framework. It means the program can gracefully exit at the times of error, instead of just crashing.

Whenever an exception occurs, an Exception object is constructed, either by the JVM or by the method executing the code. This object contains the information about the exception. Exception handling is a way of handling this Exception object.

3.1. The try-catch Block

In the following example, the try block contains the code which can throw an exception. The catch block contains the logic to handle this exception.

The catch block catches the Exception object that the code in the try block raises:

String string = "01, , 2010";
DateFormat format = new SimpleDateFormat("MM, dd, yyyy");
Date date;
try {
    date = format.parse(string);
} catch (ParseException e) {
    System.out.println("ParseException caught!");
}

3.2. The throw and throws Keywords

Alternatively, the method can also choose to throw the exception instead of handling it. That means the logic to handle the Exception object is written somewhere else.

Usually, the calling method handles the exception in such cases:

public class ExceptionHandler {

    public static void main(String[] args) {

        String strDate = "01, , 2010";
        String dateFormat = "MM, dd, yyyy";
		
        try {
            Date date = new DateParser().getParsedDate(strDate, dateFormat);
        } catch (ParseException e) {
            System.out.println("The calling method caught ParseException!");
        }
    }
}

class DateParser {
	
    public Date getParsedDate(String strDate, String dateFormat) throws ParseException {
        DateFormat format = new SimpleDateFormat(dateFormat);
        
        try {
            return format.parse(strDate);
        } catch (ParseException parseException) {
            throw parseException;
        }		
    }
	
}

Next, we’ll consider the Global Exception Handler, as a generic way to handle exceptions.

4. Global Exception Handler

The instances of the RuntimeException are optional to handle. Consequently, it still leaves a window open for getting the long stack traces at runtime. To handle this, Java provides the UncaughtExceptionHandler interface. The Thread class contains this as an inner class.

In addition to this interface, Java 1.5 release also introduced a static method setDefaultUncaughtExceptionHandler() in the Thread class. The argument of this method is a handler class that implements the UncaughtExceptionHandler interface.

Furthermore, this interface declares the method uncaughtException(Thread t, Throwable e). It will be invoked when a given thread t terminates due to the given uncaught exception e. The implementing class implements this method and defines the logic for handling these uncaught exceptions.

Let’s consider the following example that throws an ArithmeticException at runtime. We define the class Handler that implements the interface UncaughtExceptionHandler.

This class implements the method uncaughtException() and defines logic to handle uncaught exceptions in it:

public class GlobalExceptionHandler {

    public static void main(String[] args) {

        Handler globalExceptionHandler = new Handler();
        Thread.setDefaultUncaughtExceptionHandler(globalExceptionHandler);
        new GlobalExceptionHandler().performArithmeticOperation(10, 0);
    }

    public int performArithmeticOperation(int num1, int num2) {
        return num1/num2;
    }
}

class Handler implements Thread.UncaughtExceptionHandler {

    private static Logger LOGGER = LoggerFactory.getLogger(Handler.class);

    public void uncaughtException(Thread t, Throwable e) {
        LOGGER.info("Unhandled exception caught!");
    }
}

Here, the currently executing thread is the main thread. Thus, its instance is passed to the method uncaughtException() along with the raised exception. The class Handler then handles this exception.

In this way, the UncaughtExceptionHandler helps in managing unhandled exceptions at runtime. However, it breaks the idea of catching and handling the exception close to the point of origin.

5. Conclusion

In this article, we took time to understand what the exceptions are, and what are the basic ways to handle them. Also, we identified that the global exception handler is a part of the Thread class and it handles the uncaught runtime exceptions.

Then, we saw a sample program that throws a runtime exception and handles it using a global exception handler.

The example codes for this article can be found over on GitHub.