Factoring try catch

Question

I have a Java EE application with dozens of web services using the same pattern:

public Response myWebService1() {     try {         // do something different depending on the web service called     } catch (MyCustomException e1) {         return Response.status(409).build();     } catch (UnauthorizedException e2) {         return Response.status(401).build();     } catch (Exception e3) {         return Response.status(500).build();     } } 

Is that possible to factorize this piece of code?

Answer 1

If this is a JAX-RS environment, see Tunaki's answer, handling this is specifically catered for and wonderfully simple.

If not:

You can have a functional interface accepting a function that can throw exceptions and returns a Response:

@FunctionalInterface public interface Responder {     Response handleRequest() throws Exception; } 

(As Dici points out, you could make that a generic ThrowingSupplier or similar, since you're allowing it to throw Exception.)

Then have a helper method accepting an instance of it:

private static Response respond(Responder responder) {     try {         return responder.handleRequest();     } catch (MyCustomException e1) {         return Response.status(409).build();     } catch (UnauthorizedException e2) {         return Response.status(401).build();     } catch (Exception e3) {         return Response.status(500).build();     } } 

...and use it via a lambda:

public Response myWebService1() {     return respond(() -> {         // Do stuff here, return a Response or throw / allow throws on error     }); } 

Answer 2

Since this is in a JAX-RS context, there is a much better way, that does not rely on catching a lot of different exceptions: use an ExceptionMapper. This is a built-in mechanism of JAX-RS 1.0 that translates an exception type into a proper Response object to send to the client.

In your case, you could have the following classes defined once in your application:

@Provider public class UnauthorizedExceptionMapper implements ExceptionMapper<UnauthorizedException> {    public Response toResponse(UnauthorizedException e) {       return Response.status(401).build();    } } 

@Provider public class MyCustomExceptionMapper implements ExceptionMapper<MyCustomException> {    public Response toResponse(MyCustomException e) {       return Response.status(409).build();    } } 

@Provider public class CatchAllExceptionMapper implements ExceptionMapper<Exception> {    public Response toResponse(Exception e) {       return Response.status(500).build();    } } 

The @Provider annotation tells the JAX-RS runtime to discover this class when scanning. This makes sure that, wherever in your code, if a MyCustomException is thrown (and not explicitly catched), a 409 response will be returned. The code in your application would simply become:

public Response myWebService1() {     // do something, and don't catch anything; just care about the happy path } 

The exception hierarchy is correctly taken into account. If the application code throws a MyCustomExceptionMapper, JAX-RS will look for an exception mapper registered with that type, and will go up the super class if it can't find one: this way, there can be a catch-all exception mapper handling every other case.