How to use HttpStatus messages

Spring provides a mechanism for managing exceptions through the tag @ControllerAdvicethat can be used in a class to use it as an http interceptor, so that each exception that you define goes to this class and you can modify the response that you decide to send in exception case as well as the "HTTP status code" . We are going to see the whole process, the first thing is to have a controller with our endpoint:

@RestController()
public class MyAwesomeCoffeeController {

    @Autowired 
    private CoffeeService coffeeService;

    @GetMapping(value = '/{idCoffee}')
    public CoffeeResponse getCoffeeInfo(@PathVariable('idCoffee') String idCoffee) {
        coffeeService.getCoffeeById(idCoffee);
    }
}

This class is the controller, to simplify the code we have not added the service injection that defines the getCoffee method that corresponds to the URI:

Http.GET www.miurlfavorita.com/coffee/{id}

One important thing is that the controller does not have any type of logic since this is not its function, its function is to redirect the HTTP requests received by the server to the corresponding service that is in charge of carrying out the necessary logic, including exception management. Following our example:

@Service()
public class MyAwesomeCoffeeService(){

    public CoffeeResponse getCoffeeById(String idCoffee){
        ...look for coffee info at a repository...
    }
}

For simplicity, we've removed the data access logic from the service but keep in mind the separation of responsibilities (calling a repository to fetch the data). Now, going back to the original question, I need to be able to send responses in case of errors since my current code will only send a 200OK or 500INTERNAL_SERVER_ERROR by default in case of failure of my code. For this, Spring makes the @ControllerAdvicer tag available to you and there are several things you can do with it, let's see a very simple example, we create our exception handler:

@ControllerAdvice
@Log
public class GlobalExceptionHandler {

    public static final String INTERNAL_ERROR_CUSTOM_MESSAGE = '... whatever internal error happened ...'

    /**
     * this method catches every exception to send a custom error json response
     */
    @ExceptionHandler(Exception) //checkForEveryException
    @ResponseStatus(code = HttpStatus.INTERNAL_SERVER_ERROR, reason = "Error")
    public void everyException(Exception e) {
        log.info(INTERNAL_ERROR_CUSTOM_MESSAGE);
    }
}

This exception handler is called in each HTTP request when an exception is thrown and searches if there is a method that is activated with that exception (the one defined in @ExceptionHandler), in our example, we have put Exception that basically corresponds to any error in our application , this can be useful if we want to modify the general error response for any exception, we can modify the error message, status code, define a different error json than the generic one... This layer is in charge of handling exceptions in controllers and nothing more.

But in our case, we may want to add a new exception that corresponds to a different http code, for example, in our case we can request a coffee with an id that does not exist in the database and return an error response with a code 404NOT_FOUND . For this we have to throw a specific exception in our service (ALWAYS in a service that is in charge of the logic of our application). In our case, being a "not found", we can create an Exception EntityNotFoundException():

/**
* this exception is used to throw an exception if no data is found at DDBB
*/
public class EntityNotFoundException extends Exception {

    EntityNotFoundException(String message) {
        super(message);
    }
 }

Well, now that we have our custom exception (an exception that can be thrown when there is no coffee in the database), we have to map this exception to an HTTP 404 response, for this we add the corresponding method to the exception handler that we have previously created:

@ControllerAdvice
@Log
public class GlobalExceptionHandler {

    public static final String INTERNAL_ERROR_CUSTOM_MESSAGE = '... whatever internal error happened ...';

    /**
     * this method catches every exception to send a custom error json response
     */
    @ExceptionHandler(Exception) //checkForEveryException
    @ResponseStatus(code = HttpStatus.INTERNAL_SERVER_ERROR, reason = "Error")
    public void everyException(Exception e) {
        log.info(INTERNAL_ERROR_CUSTOM_MESSAGE);
    }

   /**
     * this method only catches our EntityNotFoundException
     */
    @ExceptionHandler(EntityNotFoundException)
    @ResponseStatus(code = HttpStatus.NOT_FOUND, reason = "No coffee found")
    public void everyException(EntityNotFoundException e) {
        log.info(e.message);
    }
}

Now our http requests have two possible error responses, the generic 500 that we have previously defined or the 404 that we have defined in the second method. In order for our server to send this 404, we simply have to throw the EntityNotFoundException in our service when we consider it necessary, for example:

@Service()
public class MyAwesomeCoffeeService(){

    public CoffeeResponse getCoffeeById(String idCoffee){
        Coffee coffee = coffeeRepository.findByIdCoffee(idCoffee);
        if(coffee == null){
            throw new EntityNotFoundException("No coffee with that id");
        }
    }
}

And with this there would be our complete flow, fully respecting the separation of responsibilities. Note that when throwing the exception you can send a message as a parameter that is what is being added to the log in the exception handler, you can use this to send information to the exception handler that you may need to manage the error.

In the case of having to respond to other statuses (400, 404, 500, etc) you would have to handle exceptions in the controller, remember that status 200 is when everything goes as expected.

But where do those errors come from? well, they will be defined in the BO (@Service) of your application by yourself, according to the logic proposed for the development of your application.

Here an example:

Service

@Autowired
public ContactsBo(ContactsRepository contactsRepository) {
    this.contactsRepository = contactsRepository;
}

public List<Contact> returnAll() {
    if (!this.contactsRepository.findAll().isEmpty()) {
        return this.contactsRepository.findAll();
    }
    throw new NoContactsFoundException();
}

public List<Contact> returnByName(String name) {
    if (!this.contactsRepository.findContactByName(name).isEmpty()) {
        return this.contactsRepository.findContactByName(name);
    }
    throw new NoContactsFoundException();
}

You can see how in case of not finding any contact in the database I will return a specific exception (made by me for my particular case) which will be cached in the controller and treated with a 404 NOT FOUND status.

Controller

@RequestMapping(value = "/contacts", method = RequestMethod.GET)
public ResponseEntity<ContactsResponse> contacts() {
    try {
        LOGGER.info(START_RETURN_ALL, Contact.class);
        List<Contact> contacts = this.bo.returnAll();
        return ResponseEntity.status(HttpStatus.OK).body(new ContactsResponse(contacts));
    } catch (NoContactsFoundException ex) {
        LOGGER.error(ERROR_CONTACTS_BY_NAME, ex);
        return ResponseEntity.status((HttpStatus.NOT_FOUND)).body(null);
    } catch (Exception ex) {
        LOGGER.error(ERROR_RETURN_ALL, ex);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
    }
}