Handling validation/exception responses in rest-ful app

I'll give an example using Spring REST as it has really nice built-in fucntionality for handling this problem and is probably the most popular Java REST implementation out there at the moment. One strategy is to use the Spring @ControllerAdvice annotation. This allows you to annotate a class containing exception translation logic to handle whatever exceptions arise during the processing of a request.

Methods within the class can then be annotated with the @ExceptionHandler and @ResponseStatus annotations, to define the logic for various exceptions.

For example, if we want to handle an exception that's thrown when the REST call fails to locate a resource from the persistence layer as described in the question...

    @ExceptionHandler(EmptyResultDataAccessException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public SimpleErrorModel handleEmptyDataException(HttpServletRequest request, Exception exception) {
        LOGGER.debug(exception);
        return new SimpleErrorModel("Resource not found");
    }

Or if a DataIntegrityViolationException gets thrown...

    @ExceptionHandler(DataIntegrityViolationException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public SimpleErrorModel handleDataIntegrityViolationException(HttpServletRequest request, Exception exception) {
        LOGGER.debug(exception);
        return new SimpleErrorModel("Data integrity violation");
    }

This way, when any exception gets thrown, Spring will locate the appropriate class marked with the @ControllerAdvice annotation and then search for the correct exception translation method. It resolves this method and executes the logic in the method. Here, I've got a SimpleErrorModel class that looks like this...

public class SimpleErrorModel {

    private String errorMessage;
    private String moreInfo;

    public SimpleErrorModel(String errorMessage) {
        this(errorMessage, "");
    }

    public SimpleErrorModel(String errorMessage, String moreInfo) {
        this.errorMessage = errorMessage;
        this.moreInfo = moreInfo;
    }
}

...that then gets serialized via Spring REST and returned to the front-end with the correct response code. You can also pass the HttpResponse object in to the method and do whatever you like with it.

This is just one strategy but it has the advantage of keeping all of your error handling logic and should be absolutely fine for 90% of use cases. If you need more fine-grained control, you can add qualifiers to the @ControllerAdvice annotation...

    @ControllerAdvice(annotations = RestController.class)

...to restrict the annotated classes that this handler is used for.