Categories: Spring Boot

Handle requests for a non-existent resource using Java Optional in a REST controller

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:

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:

// 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:

// 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:

// 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

Previous « Get the most out of the new hire

View Comments

Pete Developer says:

10th February 2022 at 4:23 pm

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();});