CrudRepository, JpaRepository, and PagingAndSortingRepository in Spring Data

Spring Data JPA is a powerful tool in the Spring ecosystem that simplifies the implementation of data access layers in Java applications. It provides several repository interfaces, each offering different capabilities and levels of abstraction. These interfaces allow developers to perform operations such as creating, reading, updating, and sorting data with minimal boilerplate code, streamlining the development process and enhancing productivity.

Spring Data JPA offers a variety of repository interfaces that provide different levels of abstraction and functionality for managing data access in Java applications. Understanding these repository interfaces is crucial for efficiently handling database operations with minimal boilerplate code. The three primary repository interfaces in Spring Data JPA are CrudRepository, JpaRepository, and PagingAndSortingRepository.

1. CrudRepository

The CrudRepository interface is the most basic of the repository interfaces provided by the Spring Data JPA. It defines the collection of the methods for the CRUD (Create, Read, Update, Delete) operations on the entities. By extending this interface, we can automatically gain access to these methods which include:

• save(S entity): Saves the given entity. If the entity already exists then it will be updated. Otherwise, the new entity will be created.
• findById(ID id): It can be retrieves the entity by its ID. It returns the Optional<T> which may or may not contain the entity.
• existsById(ID id): It can check whether the entity with the given ID exists.
• findAll(): It can returns all the entities as an Iterable<T>.
• count(): It can returns the total number of the entities.
• deleteById(ID id): It can deletes the entity with the given ID.
• delete(T entity): It can deletes the given entity.
• deleteAll(Iterable<? extends T> entities): It can deletes all the entities passed the argument.
• deleteAll(): It can be deletes all the entities in the repository.

Use Case: CrudRepository is an idea for the simple data management tasks where the basic CRUD operations are sufficient.

2. JpaRepository

The JpaRepository interface extends the CrudRepository and adds the more sophisticated JPA functionalities. It can provides the additional methods are specifically related with the JPA operations, such as:

• flush(): It flushes all the pending changes to the database.
• saveAndFlush(s entity): It saves the given entity and immediately flushes the changes to the database.
• deleteInBatch(Iterable<T> entities): It deletes the multiple entities in the batch which is more efficient than deleting them one by one.
• getOne(ID id): It retrieves the entity by its ID, but it can returns the reference, not the entity itself. The entity is only fetched when needed.

Use Case: JpaRepository can be suitable when you need to leverage the advanced JPA features like batch operations, custom queries, and direct interaction with the persistence context.

3. PagingAndSortingRepository

The PagingAndSortingRepository interface extends the CrudRepository and introduces the methods to handle the pagination and sorting. it can includes the following methods:

• findAll(Pageable pageable): It can returns the Page<T> of the entities where the Pageable is an abstraction for pagination information such as the page number, page size and sorting.
• findAll(Sort sort): It can be returns all the entities sorted according to the provided Sort object.
• findAllById(Iterable<ID> ids, Pageable pageable): It can fetches the entities by their IDs with pagination support.

Pagination involves dividing the result set into the manageable chunks or pages, which is useful when dealing with the large datasets. Sorting allows you to specify the order in which the data should be retrieved based on the one more fields.

Use Case: PagingAndSortingRepository is the go-to interface when you need to handle the large datasets efficiently and require support for the pagination and sorting.

Implementation of CrudRepository, JpaRepository, and PagingAndSortingRepository in Spring Data

Step 1: Create a New Spring Boot Project

Create a new Spring Boot project using IntelliJ IDEA. Choose the following options:

• Name: spring-repo-demo
• Language: Java
• Type: Maven
• Packaging: Jar

Click on the Next button.

Step 2: Add the Dependencies

Add the following dependencies to your Spring Boot project:

Step 3: Project Structure

Once the project is created, the file structure should look like this:

Step 4: Product Entity

Step 6: Setup the Repositories

Step 7: Product Service Class

Step 8: Product Controller Class

Step 9: Main Class

pom.xml

Step 10: Run the Application

Once completed the project, it will run and start at port 8080.

Step 11: Testing the Endpoints

1. Saving the Product

POST http://localhost:8080/products

2. Retrieving All the Products

GET http://localhost:8080/products

3. Retrieving Paged and Sorted Products:

GET http://localhost:8080/products/paged?page=0&size=3

Conclusion

In this article. We explored CrudRepository, JpaRepository, and PagingAndSortingRepository in the Spring Data JPA. Each repository interface can provides the specific functionalities that cater to different needs from basic CRUD operations to more advanced JPA-specific operations and pagination. By the using these repositories, we can efficiently manage the data layer with minimal code and effort of the Spring Boot application.