Spring Boot RestClient CRUD Example

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides 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.