When an API is asked for a resource that can’t be found, it is expected to return the HTTP 404 response code. To meet this requirement we don’t need to clutter our application logic with throwing exceptions and dealing with them along the way.
The concept described in this post can be especially helpful when we are working on a proof of concept or want to spike through a problem.
Typical approach
The most common way of handling a request for a non-existent resource is to throw a custom exception and propagate it to a controller layer. A developer can create an @ControllerAdvice class and deal with situations that are common among various controllers – like the 404 error. It’s a great way for advanced error management — e.g when we want to back a user with a friendly message alongside accurate details of what caused the failure.
| However, handling exceptions globally requires a deep understanding of business requirements and a well planned architecture. And it may not even be needed at all (YAGNI). |
Instead, you can start with a handy but still suitable idea described below.
Simplified approach
Optional in Spring Boot Repository interface
Spring Boot CrudRepository provides a method for getting a specified entity which returns an Optional:
|
1 2 3 4 5 |
public interface CrudRepository<T, ID> extends Repository<T, ID> { … Optional<T> findById(ID var1); … } |
The returned Optional always carries the information whether a requested resource could be found — it’s either empty or has a reference to the sought object.
Create a service
Wrap calls to the repository in a service. The following CookieService has a dependency on CookieRepository and implements one method — findOneById:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// sweet-project/backend/src/main/java/in/keepgrowing/sweetproject/cookie/CookieService.java package in.keepgrowing.sweetproject.cookie; import in.keepgrowing.sweetproject.cookie.model.Cookie; import org.springframework.stereotype.Service; import java.util.Optional; @Service public class CookieService { private CookieRepository cookieRepository; public CookieService(CookieRepository cookieRepository) { this.cookieRepository = cookieRepository; } public Optional<Cookie>findOneById(Long cookieId) { return cookieRepository.findById(cookieId); } } |
Controller response
Now we can inject the CookieService into the CookieController and call the findOneById method in the following endpoint:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
// sweet-project/backend/src/main/java/in/keepgrowing/sweetproject/cookie/CookieController.java package in.keepgrowing.sweetproject.cookie; import in.keepgrowing.sweetproject.cookie.model.Cookie; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.util.Optional; @RestController @RequestMapping("api/cookies") public class CookieController { private CookieService cookieService; public CookieController(CookieService cookieService) { this.cookieService = cookieService; } @GetMapping("{cookieId}") public ResponseEntity<Cookie> findOneById(@PathVariable Long cookieId) { Optional<Cookie> cookie = cookieService.findOneById(cookieId); return cookie.map(c -> ResponseEntity.ok().body(c)) .orElse(ResponseEntity.notFound().build()); } } |
Calling map() and orElse() functions allows us to use the mapping function if a value is present — when the cookie is found it will be returned in the response body with status 200. In case of an empty Optional, the mapping function is omitted and the endpoint returns an empty response body with the 404 status.
Test
We can easily test if the response status is correct:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
// sweet-project/backend/src/test/java/in/keepgrowing/sweetproject/cookie/CookieControllerTest.java package in.keepgrowing.sweetproject.cookie; import com.fasterxml.jackson.databind.ObjectMapper; import in.keepgrowing.sweetproject.cookie.model.Cookie; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; import org.springframework.boot.test.json.JacksonTester; import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.http.MediaType; import org.springframework.test.context.junit4.SpringRunner; import org.springframework.test.web.servlet.MockMvc; import java.util.Optional; import static org.mockito.BDDMockito.given; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; @RunWith(SpringRunner.class) @WebMvcTest(value = CookieController.class) public class CookieControllerTest { @MockBean private CookieService cookieService; @Autowired private MockMvc mvc; @Test public void statusNotFoundWhenGettingNonExistentCookie() throws Exception { given(cookieService.findOneById(1L)) .willReturn(Optional.empty()); mvc.perform(get("/api/cookies/1") .contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isNotFound()); } } |
Thanks to the Optional characteristic we can handle requests for a non-existent resource in a simple and straightforward way. It’s very convenient when we want to create a minimum viable product and we can always add more sophisticated error handling in a future iteration.
Photo by Pawel Janiak on StockSnap
Great example. Is there a way to add multiple commands and still return the ResponseEntity? Trying to do something like:return ifPresentOrElse(repoService.findById(inId), i -> {i.setStatus(inStatus);repoService.save(i);ResponseEntity.ok().body(i);}, () -> {LOG.error(“Object not available”);ResponseEntity.notFound().build();});