Java: Write a generic method that throws any RuntimeException

Question

I am writing a method that basically does one simple thing, log the error message and throw a runtime exception using the same error message. I want it to be able to throw any child exception of RuntimeException. The method I have got is:

public static <T extends RuntimeException> void logErrorAndThrowException(Logger logger, String errorMessage, Class<T> exceptionClazz) throws T {
        logger.error(errorMessage);
        RuntimeException runtimeException = new RuntimeException(errorMessage);
        throw exceptionClazz.cast(runtimeException);   // Not work!!
    }

I have have this exception defined:

public final class MyException extends RuntimeException {
    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }

    public MyException(Throwable cause) {
        super(cause);
    }

    public MyException(String message, Throwable cause) {
        super(message, cause);
    }
}

I then invoke the method using:

   logErrorAndThrowException(logger, "This is an error message", MyException.class);

The commented line above will fail with an cast exception. I then tried another implementation of:

public static <T extends RuntimeException> void logWarningAndThrowException(Logger logger, String errorMessage, Class<T> exceptionClazz) throws T {
    logger.error(errorMessage);
    try {
        throw exceptionClazz.newInstance();
    } catch (InstantiationException e) {
        // handle
    } catch (IllegalAccessException e) {
        // handle
    }
}

With this implementation, I can only invoke the no-arg constructor of my exception hence cannot set the error message.

Can anyone help with this?

Answer 1

You first need to grab the appropriate constructor for your exception class before you instantiate it. When you do:

throw exceptionClazz.cast(runtimeException);   // Not work!!

this cannot work since your class is a subclass of RuntimeException.

You can do:

final Constructor<T> c = exceptionClazz.getConstructor(String.class);
throw c.newInstance(theMessage);

But, really, don't: you'll have to deal with all possible exceptions of those two reflection methods...

Another solution, which does not involve reflection, would be to have an interface such as:

public interface ExceptionCreator<T extends RuntimeException>
{
    T doException(String whatsWrong);
}

then you have an IdentityHashMap:

// IdentityHashMap because all Class objects are singletons
private static final Map<Class<? extends RuntimeException>, ExceptionCreator<?>> MAP
    = new IdentityHashMap<>;


// fill the map in a static initialization block

Your method would then be:

public static <T extends RuntimeException> void logErrorAndThrowException(Logger logger,     
    String errorMessage, Class<T> exceptionClazz) throws T
{
    logger.error(errorMessage);
    // Note: no checks for null here. If null, just throw a "plain" RuntimeException
    throw MAP.get(exceptionClazz).doException(errorMessage);
}

Answer 2

You can create an Exception without throwing it. Since you need to know the class anyway for your method, use the RuntimeException directly as a parameter. There is no point in trying to use reflection here imho.

public static <T extends RuntimeException> void logErrorAndThrowException(Logger logger, T exception) throws T {
    logger.error(exception.getMessage());
    throw exception;   // works !!! ;-)
}