Suppressed Exceptions

#What are Suppressed Exceptions?

A suppressed exception is an exception that occurs while closing a resource, but is not allowed to replace the original (primary) exception.

This concept was introduced in Java 7 along with try-with-resources. The goal is to preserve both exceptions instead of losing one.

#Why Were Suppressed Exceptions Introduced?

Before Java 7, consider this example:

try {
    throw new RuntimeException("Main Exception");
} finally {
    throw new RuntimeException("Close Exception");
}

RuntimeException: Close Exception

Problem: Main Exception is lost forever. The exception thrown from finally replaces the original exception, which makes debugging difficult.

The Problem with Resource Cleanup

try {
    // Read file
    throw new IOException("Read Failed");
} finally {
    reader.close();
}

#Java 7 Solution

With try-with-resources, Java preserves both exceptions.

The original exception remains the main exception. The cleanup exception becomes a suppressed exception.

Example

class MyResource implements AutoCloseable {
    @Override
    public void close() {
        throw new RuntimeException("Close Failed");
    }
}

Usage:

try (MyResource resource = new MyResource()) {
    throw new RuntimeException("Business Failed");
}

RuntimeException: Business Failed
    Suppressed: RuntimeException: Close Failed

Notice:

• The primary exception is preserved.
• The closing exception is suppressed.

#Primary vs Suppressed Exception

#How Java Stores Suppressed Exceptions

Every Throwable contains a list of suppressed exceptions. Methods (added in Java 7):

addSuppressed(Throwable exception)
getSuppressed()

getSuppressed()

try (MyResource resource = new MyResource()) {
    throw new RuntimeException("Main");
} catch (Exception e) {
    for (Throwable t : e.getSuppressed()) {
        System.out.println(t.getMessage());
    }
}

Close Failed

addSuppressed()

Java adds suppressed exceptions automatically in try-with-resources, but you can also do it manually:

Exception main = new Exception("Main");
Exception cleanup = new Exception("Cleanup");

main.addSuppressed(cleanup);

throw main;

Exception: Main
    Suppressed: Exception: Cleanup

#Multiple Resources

try (
    ResourceA a = new ResourceA();
    ResourceB b = new ResourceB()
) {
    throw new RuntimeException("Main");
}

Closing order: ResourceB.close() → ResourceA.close(). If both close() methods throw exceptions:

#Resource Closing Flow

Real JDBC Example

try (
    Connection con = dataSource.getConnection();
    PreparedStatement ps = con.prepareStatement(sql);
    ResultSet rs = ps.executeQuery()
) {
    // Business logic
}

If query execution fails and closing the ResultSet also fails, Java reports the primary SQLException with the closing failure as a suppressed SQLException. Nothing is lost.

Printing Suppressed Exceptions

catch (Exception e) {
    e.printStackTrace();
}

RuntimeException: Main Exception
    Suppressed: RuntimeException: Close Exception

Modern JVMs automatically print suppressed exceptions in stack traces.

#Suppressed vs Cause

Many developers confuse these concepts.

Exception Chaining vs Suppressed Exceptions

Exception chaining:

throw new FileUploadException("Upload Failed", e);

#Enterprise Perspective

In enterprise applications, suppressed exceptions are commonly seen with JDBC, file I/O, Apache POI, ZIP processing, network sockets, HTTP clients and cloud SDKs.

Most frameworks rely on try-with-resources, so suppressed exceptions are handled automatically. Developers should still know how to inspect them when debugging production issues.