Replacing generic exceptions with more specific exception types?

Question

For a project I've been working on, we have some blocks that look like this:

Class A:

try {
   callSomeMethod();
}
catch (Exception e) {
   throw new SomeCustomExceptionTypeForMetrics("");
}

However, I was tasked with replacing all instances where we catch generic exceptions with only specific "expected" types of exceptions.

The problem is callSomeMethod() has something like this

Class B:

try {
    if (someCondition...) {

    }
    else {
       //failed
       throw new RuntimeException("Timeout while waiting for results")
    }
}
catch(InterruptedException e) {
   // do some failure stuff here
   throw new RuntimeException("Something here");
}

Ideally, my group has asked me to change as little as possible, and I can't change the signature for callSomeMethod(), but they also don't want to just catch any RuntimeException in Class A since they don't want to catch just any type of RuntimeException - only the ones we're excepting from Class B.

What is the best way to handle this?

Change those `RuntimeExeption`s to something more specific. Create custom classes if needed. — Sotirios Delimanolis, May 11 '16 at 16:01
Did I Understand this correct: You are supposed to catch RuntimeExceptions but only if they explicitly got thrown in class B in the java code with "throw new RuntimeException()" while ignoring those that might come from somewhere else? — OH GOD SPIDERS, May 11 '16 at 16:09
Thanks for the suggestions. To answer 911DidBush and slambeth: * Basically, if any other exception is thrown besides the ones we expect (InterruptedException or if we throw one as a result of the if condition), we shouldn't catch it in Class A. * Class B can be modified, but the signature can't be — CustardBun, May 11 '16 at 16:16

score 0 · Answer 1 · answered May 11 '16 at 16:10

Supposing that your callSomeMethod's signature contains throws Exception, and you can't change it: Change the RuntimeExceptions in the method to a custom Exception class, and then in Class A:

try {
   callSomeMethod();
}
catch (Exception e) {
   if(e instanceof CustomException)
       //Log it or something, for metrics?
}

This is kind of silly, but might be necessary if you can't change the method signature. (If you can change it, you could catch the CustomException directly.) You could even make a method in your logger that takes an Exception, checks what type it is, and acts accordingly. Then just use this method in every catch statement that you need to edit.

While designing this solution, keep in mind that RuntimeExceptions don't need to be caught. It could save you some trouble.

score 0 · Answer 2 · answered May 11 '16 at 16:11

If you chnage your code in class B as below

try {
        if (someCondition...) {

        }
        else {
           //failed
           throw new MyRuntimeException("Timeout while waiting for results")
        }
    }
    catch(InterruptedException e) {
       // do some failure stuff here
       throw new MyRuntimeException("Something here");
    }

and define MyRuntimeException as :

class MyRuntimeException extends RuntimeException{
..
}

In class A, you only need to catch MyRuntimeException exception .

Hope this solve your problem!!

Replacing generic exceptions with more specific exception types?

2 Answers2