JPA Repositories & CRUD Operations

Table of Contents

1. Introduction to JPA Repositories
2. CRUD Operations in Spring Data JPA
3. Working with Repository Interfaces
4. Customizing CRUD Operations
5. Paging and Sorting with JPA Repositories
6. Conclusion

1. Introduction to JPA Repositories

In Spring Data JPA, repositories are used to handle database operations. A repository is an interface that allows you to interact with the database without needing to write the actual implementation. Spring Data JPA provides various repository interfaces that can be extended to provide different levels of functionality, such as JpaRepository, CrudRepository, and PagingAndSortingRepository.

By extending these interfaces, Spring Data JPA automatically provides the implementation of common CRUD operations (Create, Read, Update, Delete), as well as other functionalities like pagination and sorting. This significantly reduces the amount of code needed for database interactions.

Types of JPA Repository Interfaces

• Repository: The root interface for all Spring Data repositories. It provides basic functionality for interacting with the database.
• CrudRepository: Extends Repository and provides methods for basic CRUD operations like save(), findById(), findAll(), and delete().
• PagingAndSortingRepository: Extends CrudRepository and adds support for pagination and sorting.
• JpaRepository: Extends PagingAndSortingRepository and CrudRepository, adding more JPA-specific features like flushing the persistence context and deleting in batch.

2. CRUD Operations in Spring Data JPA

Spring Data JPA provides automatic implementation of the basic CRUD operations, which are defined in the CrudRepository interface.

a. Create Operation: save()

The save() method is used to insert a new entity or update an existing entity in the database. If the entity already exists (determined by the ID), it will be updated; otherwise, it will be inserted as a new record.

javaCopyEdit// Create a new Employee
Employee employee = new Employee();
employee.setName("John Doe");
employee.setDepartment("Engineering");
employeeRepository.save(employee);

b. Read Operations: findById(), findAll()

• findById(): Finds an entity by its ID.

javaCopyEditOptional<Employee> employee = employeeRepository.findById(1L);
employee.ifPresent(emp -> System.out.println(emp.getName()));

• findAll(): Retrieves all entities from the database.

javaCopyEditList<Employee> employees = employeeRepository.findAll();
employees.forEach(emp -> System.out.println(emp.getName()));

You can also apply custom queries by defining query methods in the repository interface.

c. Update Operation: save()

The save() method also handles updating an entity. If the entity already exists (based on its ID), Spring Data JPA will update it.

javaCopyEdit// Update an existing Employee
Employee existingEmployee = employeeRepository.findById(1L).orElseThrow();
existingEmployee.setDepartment("HR");
employeeRepository.save(existingEmployee);

d. Delete Operation: deleteById(), delete()

• deleteById(): Deletes an entity by its ID.

javaCopyEditemployeeRepository.deleteById(1L);

• delete(): Deletes a specific entity instance.

javaCopyEditEmployee employee = employeeRepository.findById(1L).orElseThrow();
employeeRepository.delete(employee);

3. Working with Repository Interfaces

A JPA repository interface typically extends one of the Spring Data JPA base interfaces, such as JpaRepository, CrudRepository, or PagingAndSortingRepository. By extending these interfaces, your repository gets built-in functionality for common CRUD operations.

Example Repository Interface:

javaCopyEdit@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    // Custom query methods
    List<Employee> findByDepartment(String department);
    List<Employee> findByNameContaining(String name);
}

In the example above, EmployeeRepository extends JpaRepository, which provides all the basic CRUD methods. You can also define custom query methods like findByDepartment() and findByNameContaining().

Query Methods in Repositories

Spring Data JPA automatically implements query methods based on the method name. For example:

• findByDepartment(): Returns all employees in a specific department.
• findByNameContaining(): Finds employees whose names contain a specific string.

You can also use the @Query annotation to define custom JPQL or SQL queries if necessary.

javaCopyEdit@Query("SELECT e FROM Employee e WHERE e.department = :department")
List<Employee> findEmployeesByDepartment(@Param("department") String department);

4. Customizing CRUD Operations

While Spring Data JPA provides automatic CRUD methods, you can also customize your repository by defining custom methods. You can use the @Query annotation to write custom JPQL or SQL queries, or you can define more complex query methods in your repository interface.

a. Using @Query for Custom Queries

javaCopyEditpublic interface EmployeeRepository extends JpaRepository<Employee, Long> {
    
    @Query("SELECT e FROM Employee e WHERE e.department = :department")
    List<Employee> findEmployeesByDepartment(@Param("department") String department);
    
    @Query("SELECT e FROM Employee e WHERE e.name LIKE %:name%")
    List<Employee> findEmployeesByNameLike(@Param("name") String name);
}

b. Using Native Queries

You can also execute native SQL queries with the @Query annotation by specifying the nativeQuery = true attribute.

javaCopyEdit@Query(value = "SELECT * FROM employee WHERE department = :department", nativeQuery = true)
List<Employee> findEmployeesByDepartmentNative(@Param("department") String department);

c. Modifying Data with Custom Queries

You can use the @Modifying annotation along with @Query to execute update or delete queries.

javaCopyEdit@Modifying
@Query("UPDATE Employee e SET e.department = :department WHERE e.id = :id")
void updateEmployeeDepartment(@Param("id") Long id, @Param("department") String department);

5. Paging and Sorting with JPA Repositories

Spring Data JPA provides support for pagination and sorting of results. This is particularly useful when dealing with large datasets.

a. Paging

To fetch a subset of data (for example, a specific page of results), use the Pageable interface.

javaCopyEditPage<Employee> page = employeeRepository.findAll(PageRequest.of(0, 10)); // Page 0, 10 items per page
page.getContent().forEach(emp -> System.out.println(emp.getName()));

b. Sorting

To sort the results based on one or more fields, use the Sort class.

javaCopyEditList<Employee> sortedEmployees = employeeRepository.findAll(Sort.by("name").ascending());

You can also combine pagination and sorting.

javaCopyEditPage<Employee> sortedPage = employeeRepository.findAll(PageRequest.of(0, 10, Sort.by("name").descending()));

6. Conclusion

Spring Data JPA makes working with databases in Java applications straightforward by providing a repository-based abstraction layer that eliminates the need to write boilerplate code. By simply extending the appropriate Spring Data JPA repository interfaces, developers can easily perform CRUD operations and more advanced queries. Custom query methods can be defined with the power of JPQL and native SQL, and support for pagination and sorting is seamlessly integrated.

In this module, we have covered:

• The basics of JPA repositories and how they simplify CRUD operations.
• The standard methods provided by Spring Data JPA for working with entities.
• How to customize repository queries with @Query and native SQL.
• How to use pagination and sorting to handle large datasets.

By leveraging Spring Data JPA repositories, you can focus on the business logic of your application and leave the database handling to the framework.