How to Build Dynamic Spring Data JPA Queries with Optional Filter Criteria?

Dynamic Spring Data JPA Repository Query with Optional Filter Criteria

Problem:

In Spring Data JPA, generating dynamic queries with optional filter criteria becomes challenging when the number of fields increases, leading to a large number of static queries that need to be manually written.

Best Approach: Specifications and Criteria API

Spring Data JPA provides the Specifications interface and Criteria API to address this issue. Specifications allow for the programmatic creation of predicates that can be dynamically combined and used to build queries.

Implementing Specifications

To use Specifications, extend the repository interface with the JpaSpecificationExecutor interface:

public interface EmployeeRepository extends JpaRepository<Employee, Integer>, JpaSpecificationExecutor<Employee> {}

Creating a Specification

Create a Java class that implements the Specification interface, defining the predicate logic for each filter criterion. For example, to create a specification for the EmployeeNumber field:

public class EmployeeNumberSpecification implements Specification<Employee> {

    private String employeeNumber;

    public EmployeeNumberSpecification(String employeeNumber) {
        this.employeeNumber = employeeNumber;
    }

    @Override
    public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
        if (employeeNumber == null || employeeNumber.isEmpty()) {
            return builder.disjunction(); // Allow any value
        }
        return builder.like(root.get("employeeNumber"), "%" + employeeNumber + "%");
    }
}

Combining Specifications

Multiple specifications can be combined using logical operators (e.g., and, or, not) to create more complex search criteria. For example, to search for employees with a specific EmployeeNumber and Profession:

Specification<Employee> employeeNumberSpec = new EmployeeNumberSpecification("10");
Specification<Employee> professionSpec = new ProfessionSpecification("IT");
Specification<Employee> combinedSpec = Specification.where(employeeNumberSpec).and(professionSpec);

Executing the Query

Specifications can be used with findAll and other methods of the JPA repository to execute the dynamic query:

List<Employee> employees = employeeRepository.findAll(combinedSpec);

Benefits of Specifications:

• Extensibility: Easily add and combine search criteria as business requirements evolve.
• Dynamic Filtering: Filter data based on arbitrary criteria without the need for predefined queries.
• Robustness: Handles null values and other edge cases gracefully.
• Code Clarity: Separates query logic from business logic, enhancing testability and maintainability.

The above is the detailed content of How to Build Dynamic Spring Data JPA Queries with Optional Filter Criteria?. For more information, please follow other related articles on the PHP Chinese website!