30.10. Developing REST APIs with Spring Boot: Implementing CRUD operations

The development of REST APIs has become an essential component in modern application architecture. Spring Boot, a Spring Framework project, simplifies the process of building robust and efficient APIs. This in-depth guide explores implementing CRUD (Create, Read, Update, Delete) operations in a REST API using Spring Boot.

Introduction to Spring Boot

Spring Boot is an extension to the Spring Framework that offers a quick and easy way to create Spring applications. It is designed to simplify the start of development and reduce configuration time. Spring Boot does this by offering default configurations and ready-to-use components, and it integrates well with other tools and frameworks.

Configuring the Environment

To get started, you need to have the Java Development Kit (JDK) installed on your machine, as well as a build tool like Maven or Gradle. With these prerequisites met, you can create a new Spring Boot project using Spring Initializr (start.spring.io), an online tool that generates the basic project structure with the desired dependencies.

Creating the Project

After configuring the project with the necessary dependencies, such as Spring Web and Spring Data JPA, you are ready to start developing your REST API. The structure of a typical Spring Boot project includes packages for controllers, services, repositories, and entities.

Understanding Components

Before diving into implementing CRUD operations, it is important to understand the components involved:

• Entity: a Java class that represents the data table in the database. JPA annotations are used to map the class to the table.
• Repository: an interface that extends JpaRepository or CrudRepository, providing data access methods.
• Service: a class that contains business logic and communicates with the repository to access the database.
• Controller: a class that handles HTTP requests and maps CRUD operations to service methods.

Implementing CRUD Operations

Now, let's detail the implementation of CRUD operations in our REST API with Spring Boot:

Create

To create a new resource, we define a POST method in the controller. This method accepts a DTO (Data Transfer Object) object that is mapped to the entity and persisted in the database using the service.

Read

To read resources, we define GET methods in the controller. We can implement reading all resources or a specific resource by ID. The service is responsible for fetching data from the repository and returning it to the controller.

Update

To update a resource, we use a PUT or PATCH method. The method receives the ID of the resource to be updated and a DTO object with the new data. The service fetches the existing resource, updates it with the new data and saves the changes.

Delete

To delete a resource, a DELETE method is defined in the controller. The service is called to remove the resource from the database using the provided ID.

Practical example

Let's create a simple API to manage books in a library. We will start by defining the Book entity, the BookRepository repository, the BookService service and the BookController controller.

Book Entity

@Entity
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String author;
    // Getters and Setters omitted
}

BookRepositoryRepository

public interface LivroRepository extends JpaRepository<Book, Long> {
}

BookService Service

@Service
public class BookService {
    private final BookRepository bookRepository;
    // Constructor and CRUD methods omitted
}

BookController Controller

@RestController
@RequestMapping("/books")
public class BookController {
    private final BookService bookService;
    // Constructor and CRUD endpoints omitted
}

With these classes defined, we implement the CRUD methods in the service and map them to the REST endpoints in the controller. For example, to add a book we would have:

@PostMapping
public ResponseEntity<Book> addBook(@RequestBody Book book) {
    Book newBook ​​= bookService.save(book);
    return new ResponseEntity<>(newBook, HttpStatus.CREATED);
}

This is a simplified example. In practice, you will also need to handle exceptions, validate input, and perhaps implement security and authentication.

Conclusion

Creating REST APIs with Spring Boot is a simplified task thanks to its rich and well-integrated ecosystem. By following this guide, you will be able to implement CRUD operations and will be on your way to developing complete and efficient REST APIs. Remember that practice is essential to improving your skills, so keep exploring and building projects with Spring Boot.