Spring Boot RestClient CRUD Example

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

In this blog post, we'll explore how to perform Create, Read, Update, and Delete (CRUD) operations using RestClient which was introduced in Spring Framework 6.1 and Spring Boot 3.2.

RestClient Overview

RestClient is designed to offer a more fluent API experience, similar to WebClient, but with a focus on synchronous HTTP calls. It's perfect for applications that need the ease of RestTemplate without the overhead of the reactive stack.

Advantages of Using RestClient 

Simplicity: The fluent API makes it straightforward to configure and execute HTTP requests.

Synchronous Operations: Ideal for applications that don’t require the non-blocking nature of WebClient.

Minimal Configuration: Unlike WebClient, it doesn’t require the reactive web stack.

Pre-requisites

We are going to use RestClient to make CRUD REST API calls so first we need to have CRUD REST APIs up and running. Use the below tutorial to build CRUD REST APIs for a User entity:

Spring Boot REST API CRUD Example With MySQL Database

The User Entity

Let's revisit the User entity from this tutorial. A User JPA entity class with the following fields: 

• id - primary key
• firstName - user's first name
• lastName - user last name
• email - user email ID

package net.javaguides.springboot.entity;

import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(nullable = false)
    private String firstName;
    @Column(nullable = false)
    private String lastName;
    @Column(nullable = false, unique = true)
    private String email;
}

Note that we are using Lombok annotations to reduce the boilerplate code such as getter/setter methods, and constructors.

We are using below JPA annotations below to map an Entity with a database table:

@Entity annotation is used to mark the class as a persistent Java class.

@Table annotation is used to provide the details of the table that this entity will be mapped to.

@Id annotation is used to define the primary key.

@GeneratedValue annotation is used to define the primary key generation strategy. In the above case, we have declared the primary key to be an Auto Increment field.

@Column annotation is used to define the properties of the column that will be mapped to the annotated field. You can define several properties like name, length, nullable, updateable, etc.

CRUD Operations with RestClient 

Create (POST):

To create a new User:

public User createUser(User user) {
    return restClient.post()
                     .uri("/api/users")
                     .body(user)
                     .retrieve()
                     .bodyTo(User.class);
}

Let's understand the above methods:

• post() - This method initiates a POST request. 
• uri("/api/users") - This method specifies the URI of the endpoint. 
• body(user) - This method sets the request body with the User object. 
• retrieve() - This method fetches the response. 
• bodyTo(User.class) - This method converts the response body to a User object.

Read (GET): 

Retrieve a user by ID:

public User getUser(Long id) {
    return restClient.get()
                     .uri("/api/users/" + id)
                     .retrieve()
                     .bodyTo(User.class);
}

List all users:

public List<User> getAllUsers() {
    return restClient.get()
                     .uri("/api/users")
                     .retrieve()
                     .bodyToList(User.class);
}

Let's understand the above methods:

• get() - This method initiates a GET request. 
• For a single user, uri("/api/users/" + id) targets the specific user by ID. 
• bodyTo(User.class) and bodyToList(User.class) parse the response into a User object or a list of User objects, respectively. 

Update (PUT): 

Update the existing User object:

public User updateUser(Long id, User user) {
    return restClient.put()
                     .uri("/api/users/" + id)
                     .body(user)
                     .retrieve()
                     .bodyTo(User.class);
}

• put() - This method starts a PUT request. 
• uri() and body() functions are similar to POST, targeting a specific user and sending updated data. 

Delete (DELETE): 

public void deleteUser(Long id) {
    restClient.delete()
              .uri("/api/users/" + id)
              .retrieve()
              .toBodilessEntity();
}

• delete() - This method initiates a DELETE request. 
• uri("/api/users/" + id) points to the specific user. 
• toBodilessEntity() processes the response without expecting a body (common for DELETE operations).

Complete Code

Here is the complete code to perform CRUD operations using RestClient:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.RestClient;

import java.util.List;

@Service
public class UserRestClientService {

    @Autowired
    private RestClient restClient;

    // Create
    public User createUser(User user) {
        return restClient.post()
                         .uri("/users")
                         .body(user)
                         .retrieve()
                         .bodyTo(User.class);
    }

    // Read
    public User getUser(Long id) {
        return restClient.get()
                         .uri("/users/" + id)
                         .retrieve()
                         .bodyTo(User.class);
    }

    public List<User> getAllUsers() {
        return restClient.get()
                         .uri("/users")
                         .retrieve()
                         .bodyToList(User.class);
    }

    // Update
    public User updateUser(Long id, User user) {
        return restClient.put()
                         .uri("/users/" + id)
                         .body(user)
                         .retrieve()
                         .bodyTo(User.class);
    }

    // Delete
    public void deleteUser(Long id) {
        restClient.delete()
                  .uri("/users/" + id)
                  .retrieve()
                  .toBodilessEntity();
    }
}

Conclusion 

In this blog post, RestClient is used to streamline HTTP operations for a User entity in a Spring Boot application. It demonstrates a clean and intuitive approach to handling web requests with a fluent API, catering to a range of CRUD functionalities. Remember, the actual implementation may vary based on the actual features and capabilities of RestClient in future releases of Spring Framework.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Build REST APIs with Spring Boot 4, Spring Security 7, and JWT

🆕 High-Demand 80–90% OFF

[NEW] Learn Apache Maven with IntelliJ IDEA and Java 25

🆕 High-Demand 80–90% OFF

ChatGPT + Generative AI + Prompt Engineering for Beginners

🚀 Trending Now 80–90% OFF

Spring 7 and Spring Boot 4 for Beginners (Includes 8 Projects)

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Building Real-Time REST APIs with Spring Boot - Blog App

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Building Microservices with Spring Boot and Spring Cloud

🌟 Top Rated 80–90% OFF
Available in Udemy for Business

Java Full-Stack Developer Course with Spring Boot and React JS

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Build 5 Spring Boot Projects with Java: Line-by-Line Coding

🌟 Top Rated 80–90% OFF

Testing Spring Boot Application with JUnit and Mockito

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Spring Boot Thymeleaf Real-Time Web Application - Blog App

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Master Spring Data JPA with Hibernate

🔥 Bestseller 80–90% OFF
Available in Udemy for Business

Spring Boot + Apache Kafka Course - The Practical Guide

🎓 Student Favorite 80–90% OFF
Available in Udemy for Business

Java Testing: Mastering JUnit 5 Framework

🆕 New 80–90% OFF

Reactive Programming in Java: Spring WebFlux and Testing

🌟 Top Rated 80–90% OFF

Spring Boot + RabbitMQ Course - The Practical Guide

🌟 Top Rated 80–90% OFF
Available in Udemy for Business

Functional Programming in Java (Includes Java Collections)

🎓 Student Favorite 80–90% OFF

ChatGPT for Java Developers: Boost Your Productivity with AI

🚀 Trending Now 80–90% OFF