日志处理中Throwable与Exception的适配问题

Great question! I’ve dealt with this exact scenario when working with logging libraries that only accept Exception types but need to handle all Throwable instances (like Error subclasses). The key is to leverage Java’s exception chaining feature, which lets you attach the original Throwable as the cause of your new Exception—this preserves the full stack trace and context.

Solution 1: Use Exception’s Cause Constructor #

The simplest way is to create a new Exception using the constructor that accepts both a message and a cause. This automatically links the original Throwable to the new exception, preserving its stack trace:

public Exception convertThrowableToException(Throwable throwable) {
    // If it's already an Exception, just return it directly
    if (throwable instanceof Exception) {
        return (Exception) throwable;
    }
    // Wrap non-Exception Throwables with the original as the cause
    return new Exception("Wrapped non-Exception Throwable: " + throwable.getClass().getName(), throwable);
}

When your logger prints this exception, it will include the full stack trace of the original Throwable under the Caused by: section—no debugging information is lost.

Solution 2: Create a Custom Wrapper Exception #

For better clarity (especially if you need to distinguish wrapped throwables from regular exceptions), you can define a custom exception class that explicitly wraps Throwable:

public class WrappedThrowableException extends Exception {
    public WrappedThrowableException(Throwable cause) {
        // Pass the cause's message and the cause itself to the super constructor
        super(cause.getMessage(), cause);
    }

    // Optional: Add a constructor with a custom message for more context
    public WrappedThrowableException(String message, Throwable cause) {
        super(message, cause);
    }
}

Then use it like this:

public Exception convertThrowableToException(Throwable throwable) {
    if (throwable instanceof Exception) {
        return (Exception) throwable;
    }
    return new WrappedThrowableException(throwable);
}

Why This Works #

Java’s exception handling system automatically includes the stack trace of the cause when printing exceptions. When you log the wrapped exception, your logging library will output both the stack trace of the wrapper and the full stack trace of the original Throwable (marked as Caused by:), so you don’t lose any critical debugging context.

Avoid This Common Mistake #

Don’t create a new Exception without passing the cause (e.g., new Exception(throwable.getMessage())). This will only include the wrapper’s stack trace, not the original Throwable’s—you’ll lose vital information needed to diagnose the root issue.

内容的提问来源于stack exchange，提问作者Brian Knoblauch