在多个地方使用大块异常处理

Question

I am trying to use a large block of exception handling in multiple functions, in separate classes. for example -

public class A {
  public void function funcA(input){
    try {
        randomService.randomFunction(input);
        log.info("Finished processing randomFunction");
    } catch (CustomException ex) {
        log.error("Custom exception occurred");
    } catch (MongoException ex) {
        log.error("Mongo exception occurred");
        throw ex;
    } catch (ResourceNotFoundException ex) {
        log.error("ResourceNotFound exception occurred");
    } catch (Exception ex) {
        log.error("Something totally weird happened");
        throw ex;
    }
  }
}

This is the second place. The idea here is that the code snippet inside the try block is different, but the exception handling(ie all of the catch blocks) code is the same.

public class B {
  public void function funcB(input){
    try {
        randomOtherService.randomFunction(input);
        log.info("Finished processing randomFunction");
    } catch (CustomException ex) {
        log.error("Custom exception occurred");
    } catch (MongoException ex) {
        log.error("Mongo exception occurred");
        throw ex;
    } catch (ResourceNotFoundException ex) {
        log.error("ResourceNotFound exception occurred");
    } catch (Exception ex) {
        log.error("Something totally weird happened");
        throw ex;
    }
  }
}

Now one thing I should mention is that in my case this is not an API response. So I cannot get away with using @ControllerAdvice. If it helps my use case is in Kafka consumer.

So my query is there any way I can have this exception handling in same place instead of duplicating the code? Like how @ControllerAdvice can be used to handle exceptions from @RestController is there something I can use with Kafka @StreamListener? Or can I somehow modify the lombok @Sneakythrow to and make a custom exception handler/interceptor to do all these? Or is there some better design pattern that I can follow to avoid the duplication?

Thanks in advance !

Answer 1

Here's a way to handle it – create a separate function which takes an Exception as input, and then does the common handling that you want in the various callers ( funcA() and funcB() ).

public static void handleException(Exception e) throws Exception {
    if (e instanceof CustomException) {
        log.error("Custom exception occurred");
    } else if (e instanceof MongoException) {
        log.error("Mongo exception occurred");
        throw e;
    } else if (e instanceof ResourceNotFoundException) {
        log.error("ResourceNotFound exception occurred");
    } else {
        log.error("Something totally weird happened");
        throw e;
    }
}

The callers both become pretty simple in the catch block, both just take whatever Exception was caught and hand it off to the handleException() method. funcA() below shows how this could look:

public void funcA(Object input) throws Exception {
    try {
        randomService.randomFunction(input);
        log.info("Finished processing randomFunction");
    } catch (Exception e) {
        handleException(e);
    }
}

funcB() would follow the same changes:

public void funcB(Object input) throws Exception {
    try {
        randomOtherService.randomFunction(input);
        log.info("Finished processing randomFunction");
    } catch (Exception e) {
        handleException(e);
    }
}