The right way to setup Request timeout in Spring Boot REST API? Instance Tutorial

To set request timeout on database queries or calls by utilizing Spring’s @Transactional annotation. We might set the timeout attribute that it has. It has a default worth of -1, which is identical as having no timeout in any respect.

To illustrate we’ve set this timeout to 50 seconds. An exception can be raised if the annotated technique takes longer than this period of time to execute. This method is sort of helpful for time-consuming database searches or long-running SQL queries.

Let’s see it in motion, we’ll create a easy relaxation endpoint that returns the scholar’s particulars as proven beneath.

Pupil.java

@Entity
@Desk(identify = "college students")
public class Pupil {
    @Id
    @GeneratedValue(technique = GenerationType.AUTO)

    personal int id;
    personal int age;
    personal String identify;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(identify = "department_id")
    personal Division division;

}

StudentRepo.java

public interface StudentRepo extends JpaRepository<Pupil, Integer> {

}

StudentController.java

@RestController

@RequestMapping("/api/v1/college students")

public class StudentController {

    @Autowired

    StudentRepo studentRepo;

    @Autowired

    StudentRepoCustom studentRepoCustom;





    @RequestMapping(worth = "/", technique = RequestMethod.GET)

    @Transactional(timeout = 10)

    public ResponseEntity<Listing<Pupil>> getAllStudents(){

        return new ResponseEntity<>(studentRepoCustom.getStudents(), HttpStatus.OK);

    }



    @RequestMapping(worth = "/{studentId}", technique = RequestMethod.GET)

    public ResponseEntity<?> getSingleStudent(@PathVariable int studentId){



        Non-compulsory<Pupil> s = studentRepo.findById(studentId);

        if(s.isPresent()){

            return new ResponseEntity<>(s, HttpStatus.OK);

        }else{

            Map<String, Object> errorMessage = new HashMap<>();

            errorMessage.put("message", "Entity Not Discovered");

            errorMessage.put("standing", 404);

            return new ResponseEntity<>(errorMessage, HttpStatus.NOT_FOUND);

        }

    }

    

}

StudentService.java

@Service

public class StudentService implements StudentRepoCustom {

    @Autowired

    StudentRepo studentRepo;



    @Override

    public Listing<Pupil> getStudents() {

        attempt {

            TimeUnit.SECONDS.sleep(15);

        } catch (InterruptedException ie) {

            Thread.currentThread().interrupt();

        }

        return studentRepo.findAll();

    }

}

As you’ll be able to see, StudentService class has a technique getStudents() which returns all the scholar’s data from the Pupil entity. For demonstration functions, I’ve added an execution delay of 15 seconds(one might think about it a community delay). Which means the strategy will take at the very least 15 seconds earlier than it returns a response.

In StudentController, endpoint /college students are annotated with @Transactional with a customized timeout of 10 seconds. This implies the endpoint has to reply inside 10 seconds earlier than it throws an error. This endpoint is making a name to StudentService’s getStudents technique that has a delay of 15 seconds.

Word: It’s apparent, the endpoint /college students will return a 500 error message as a result of timeout restrict because it requires a response inside 10 seconds the place as the scholar service will take at the very least 15 seconds to reply.

Error Response

org.springframework.transaction.TransactionTimedOutException: Transaction timed out: deadline was Sat Mar 04 19:26:04 GMT 2023 

{

"timestamp": "2023-03-04T14:26:09.851+00:00",

"standing": 500,

"error": "Inside Server Error",

"path": "/api/v1/college students/"

}

Profitable Response

[ {

"id": 1,

"age": 26,

"name": "James Faulkner",

"department": {

"id": 1,

"name": "Chemistry",

"capacity": 110,

"specialization": "Micro Physics"

}

} ]

Utilizing WebClient timeout

Spring introduces the WebFlux framework, which helps reactive programming. To make HTTP requests we use the WebClient interface. It’s a reactive consumer that does not block when making HTTP requests. Its default underlying HTTP consumer library is Reactor Netty.

It permits us to set a timeout on a single exterior name quite than setting it on a complete endpoint. Though the vast majority of builders now use WebClient over RestTemplate, the older RestTemplate object from Spring should have timeouts configured.

Let’s see WebClient in motion with the assistance of an instance.

Add WebFlux dependency in your venture

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-webflux</artifactId>

    <model>3.0.4</model>

</dependency>

webClient.get()

        .uri(uri)

        .retrieve()

        .onStatus(HttpStatus::isError, clientResponse -> {

            LOGGER.error("Error whereas calling endpoint {} with standing code {}",

            uri.toString(), clientResponse.statusCode());

            throw new RuntimeException("Error whereas calling  accounts endpoint");

}).bodyToMono(JsonNode.class)

        .timeout(Period.ofMillis(timeout));

@Bean

public WebClient webClient() {

    return WebClient.builder()

            .baseUrl("http://localhost:8080/api/v1")

            .clientConnector(new ReactorClientHttpConnector(

                    HttpClient.create().responseTimeout(Period.ofSeconds(10))

            ))

            .construct();

}

@GetMapping("/webclient")

public Pupil[] getWithWebClient() {

    return webClient.get()

            .uri(uriBuilder -> uriBuilder

                    .path("/college students/")

                    .construct())

            .retrieve()

            .bodyToMono(Pupil[].class)

            .block();

}

spring.mvc.async.request-timeout=milliseconds-precision

@GetMapping("/mvc-timeout")

public Callable<Listing<Pupil>> getWithMvcRequestTimeout() {

    return () -> {

        return studentRepoCustom.getStudents();

    };

}

One may want to make the most of Spring’s @Transactional technique and its timeout property to set a timeout on our database calls.