Question

I’m looking to clean up the exception mess that is currently the code base I’m working on.

The basic setup is this.

I have an interface that is implemented by a lot of classes that looks like this:

public interface TerminalMessage<E> {

   // Override for specific return data type.
   public E send(TerminalStream stream) throws Exception;
}

These classes throw a lot of different exceptions, like IOException, InterruptedException etc.

As it is now, all I do is call getMessage() on the catched exceptions and relay this message to the ui-code.

This is not very nice since I sometimes get bogus messages displayed to the user and I catch unwanted exceptions.

I’m thinking of creating a custom exception class (TerminalException) that would wrap all these kinds of exceptions.

However I’m not sure where to do the wrapping, should the wrapping be done where the exception is first thrown (in the output stream for example) or in every send() method. The former has the advantage of not adding much code, but it makes more sense to me that a stream throws IOException rather than a TerminalException.

The above design also doesn’t really solve the sometimes bad messages displayed to the user, so some tip on how to transform the thrown exceptions into something useful to the user would be great!

Thanks!

Answer 1

a custom exception is a very good idea if you have useful information in it like an error code.

just wrap everything with your TerminalException, but do not forget the cause

OR

use the first TerminalException thrown:

public class MyException extends Exception{
   String errorMessage; 

   public MyException(String message, Exception cause){
     super();

     if(cause instanceof MyException){
         // already wrapped
         errorMessage= cause.getErrorMessage();          
         initCause(cause.getCause());
     }
     else{
         // not my Exception
         errorMessage=message;
         initCause(cause); 
     } 
 ´               

   }

}