1. Overview

In this article, we’ll have a very brief look at what Exception is and go in depth about discussing the chained exceptions in Java.

Simply put, an exception is an event that disturbs the normal flow of the program’s execution. Let’s now see exactly how we can chain exceptions to get better semantics out of them.

2. Chained Exceptions

Chained Exception helps to identify a situation in which one exception causes another Exception in an application.

For instance, consider a method which throws an ArithmeticException because of an attempt to divide by zero but the actual cause of exception was an I/O error which caused the divisor to be zero.The method will throw the ArithmeticException to the caller. The caller would not know about the actual cause of an Exception. Chained Exception is used in such situations.

This concept was introduced in JDK 1.4.

Let’s see how chained exceptions are supported in Java.

3. Throwable Class

Throwable class has some constructors and methods to support chained exceptions. Firstly, let’s look at the constructors.

• Throwable(Throwable cause) – Throwable has a single parameter, which specifies the actual cause of an Exception.
• Throwable(String desc, Throwable cause) – this constructor accepts an Exception description with the actual cause of an Exception as well.

Next, let’s have a look at the methods this class provides:

• getCause() method – This method returns the actual cause associated with current Exception.
• initCause() method – It sets an underlying cause with invoking Exception.

4. Example

Now, let’s look at the example where we will set our own Exception description and throw a chained Exception:

As guessed, this will lead to:

5. Why Chained Exceptions?

We need to chain the exceptions to make logs readable. Let’s write two examples. First without chaining the exceptions and second, with chained exceptions. Later, we will compare how logs behave in both of the cases.

To start, we will create a series of Exceptions:

Now, let’s start using the above exceptions in code examples.

5.1. Without Chaining

Let’s write an example program without chaining our custom exceptions.

In the example above, logs will look like this:

5.2. With Chaining

Next, let’s write an example with chaining our custom exceptions:

Finally, let’s look at the logs obtained with chained exceptions:

We can easily compare shown logs and conclude that the chained exceptions lead to cleaner logs.

6. Conclusion

In this article, we had a look at chained exceptions concept.

The implementation of all examples can be found in the Github project – this is a Maven-based project, so it should be easy to import and run as it is.