Question

I’m working on some server-side code that wraps all exceptions before passing them to the client side, due to this all client facing methods have the following code

try{
   DoSomething();
} catch (ExceptionA e) {
   throw new CustomException(AType, e);
} catch (ExceptionB e) {
   throw new CustomException(BType, e);
} catch (Exception e) {
   throw new CustomException(Unexpected, e);
}

to have this repeated in every method seems to violate the DRY principle and I was wondering what the best way to refactor it would be. For instance I was thinking a wrapper method such as:

private void wrapException(Exception e) {
if (e instanceof ExceptionA) {
   throw new CustomException(AType, e);
}
etc...

Answer 1

Take a look at AspectJ soften exception.

Also look at Guava’s Throwables.

There is also Lamboks sneaky exception.

The other option is to use Anonymous object instances aka closures.

public abstract class Wrapper {
    public void execute() { 
        try {
            // do some boiler plate before
            this.wrap();
            // do some boiler plate after.
        } catch (ExceptionA | ExceptionB ex)  {
            Type t = determineType(ex);
            throw new CustomException(t, ex);
        }
    }
    public void abstract wrap();
}

Now in your code you do something like:

new Wrapper() {
    public void wrap() {
        DoSomething();
    }
}.execute()