Specification pattern for dynamic queries in Spring Boot - Mini Project: Build & Apply

Specification Pattern for Dynamic Queries in Spring Boot

📖 Scenario: You are building a simple product catalog application. Users want to search products by different criteria like name, category, and price range. You will use the Specification pattern to create flexible and dynamic database queries in Spring Boot.

🎯 Goal: Build a Spring Boot Specification to filter products dynamically based on user search criteria.

📋 What You'll Learn

Create a Product entity with fields: id, name, category, price

Create a Specification class to build dynamic queries

Use Specification to filter products by name, category, and price range

Combine multiple Specifications to handle multiple filters

💡 Why This Matters

🌍 Real World

Many applications need to filter data based on user input. The Specification pattern helps build flexible and reusable queries without writing many fixed methods.

💼 Career

Understanding dynamic queries with Specifications is valuable for backend developers working with Spring Boot and databases.

1

Create the Product entity

Create a Java class called Product with fields Long id, String name, String category, and Double price. Use @Entity and @Id annotations for JPA.

Spring Boot

// Your code here

Hint

Use @Entity above the class and @Id on the id field.

2

Create the ProductSpecification class

Create a class called ProductSpecification that implements Specification<Product>. Add a private field SearchCriteria criteria and a constructor to set it.

Spring Boot

import org.springframework.data.jpa.domain.Specification;

// Your code here

Hint

Implement Specification<Product> and add a constructor that takes SearchCriteria.

3

Implement the toPredicate method for dynamic filtering

In ProductSpecification, implement the toPredicate method. Use criteria.getOperation() to check if it is : for equality or > or < for price comparisons. Return the appropriate Predicate using builder.equal, builder.greaterThanOrEqualTo, or builder.lessThanOrEqualTo.

Spring Boot

    @Override
    public javax.persistence.criteria.Predicate toPredicate(javax.persistence.criteria.Root root,
            javax.persistence.criteria.CriteriaQuery query,
            javax.persistence.criteria.CriteriaBuilder builder) {
        // Your code here
    }

Hint

Use a switch on criteria.getOperation() and return the correct Predicate for each case.

4

Combine Specifications for dynamic queries

In a service or repository method, create multiple ProductSpecification instances for name, category, and price range. Combine them using Specification.where() and and() methods to build a dynamic query.

Spring Boot

// Your code here to combine specifications

Hint

Start with Specification.where(null) and add filters with and() if values are not null.

Practice

1. What is the main purpose of the Specification pattern in Spring Boot?

easy

A. To manage application configuration properties

B. To create REST API endpoints automatically

C. To handle HTTP request routing

D. To build flexible and reusable database queries dynamically

Solution

1. Step 1: Understand the role of Specification pattern

   The Specification pattern is designed to help build database queries that can be combined and reused dynamically.

2. Step 2: Compare with other options

   Options A, C, and D relate to other Spring Boot features like configuration, routing, and REST APIs, not query building.

3. Final Answer:

   To build flexible and reusable database queries dynamically -> Option D

4. Quick Check:

   Specification pattern = flexible queries [OK]

Hint: Specification pattern builds flexible queries step-by-step [OK]

Common Mistakes:

• Confusing Specification with REST controller features
• Thinking it manages app configuration
• Assuming it handles HTTP routing

2. Which of the following is the correct method signature to implement in a Specification class in Spring Boot?

easy

A. public Predicate toPredicate(Root<T> root, CriteriaQuery query, CriteriaBuilder builder)

B. public void executeQuery(String sql)

C. public List<T> findAll()

D. public void configure()

Solution

1. Step 1: Recall Specification interface method

   The Specification interface requires implementing the toPredicate method with parameters Root, CriteriaQuery, and CriteriaBuilder.

2. Step 2: Eliminate incorrect options

   Options A, B, and C do not match the Specification interface method signature.

3. Final Answer:

   public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder builder) -> Option A

4. Quick Check:

   Specification method = toPredicate(...) [OK]

Hint: Specification requires toPredicate method with root, query, builder [OK]

Common Mistakes:

• Using methods unrelated to Specification interface
• Missing correct method parameters
• Confusing with repository methods

3. Given the following Specification code snippet, what will be the result of the query?

Specification<User> spec = (root, query, builder) -> builder.equal(root.get("status"), "ACTIVE");
List<User> users = userRepository.findAll(spec);

medium

A. Throws a syntax error due to lambda usage

B. Returns all users regardless of status

C. Returns all users with status 'ACTIVE'

D. Returns users with status 'INACTIVE'

Solution

1. Step 1: Analyze the Specification lambda

   The lambda creates a predicate that filters users where the 'status' field equals 'ACTIVE'.

2. Step 2: Understand the repository call

   The findAll(spec) method applies this filter, returning only users matching the predicate.

3. Final Answer:

   Returns all users with status 'ACTIVE' -> Option C

4. Quick Check:

   Predicate filters status = ACTIVE [OK]

Hint: Predicate filters users by status 'ACTIVE' [OK]

Common Mistakes:

• Assuming it returns all users without filtering
• Thinking lambda causes syntax error
• Confusing status values

4. Identify the error in this Specification implementation:

public class UserSpec implements Specification<User> {
  public Predicate toPredicate(Root<User> root, CriteriaQuery query) {
    return builder.equal(root.get("age"), 30);
  }
}

medium

A. Missing CriteriaBuilder parameter in toPredicate method

B. Incorrect return type; should return boolean

C. Root parameter type is wrong

D. Method name should be buildPredicate

Solution

1. Step 1: Check toPredicate method signature

   The Specification interface requires three parameters: Root, CriteriaQuery, and CriteriaBuilder.

2. Step 2: Identify missing parameter

   The method is missing the CriteriaBuilder parameter, so it cannot build the predicate correctly.

3. Final Answer:

   Missing CriteriaBuilder parameter in toPredicate method -> Option A

4. Quick Check:

   toPredicate needs CriteriaBuilder parameter [OK]

Hint: toPredicate must have three parameters including CriteriaBuilder [OK]

Common Mistakes:

• Omitting CriteriaBuilder parameter
• Returning wrong type
• Wrong method name

5. How can you combine two Specifications spec1 and spec2 to create a dynamic query that matches records satisfying both conditions?

hard

A. Use spec1.or(spec2)

B. Use Specification.where(spec1).and(spec2)

C. Use spec1.add(spec2)

D. Use spec1.merge(spec2)

Solution

1. Step 1: Recall Specification combination methods

   Spring Data JPA Specification provides where(), and(), and or() methods to combine Specifications logically.

2. Step 2: Combine for AND condition

   To match records satisfying both conditions, use Specification.where(spec1).and(spec2).

3. Final Answer:

   Use Specification.where(spec1).and(spec2) -> Option B

4. Quick Check:

   Combine specs with where().and() for AND logic [OK]

Hint: Use where().and() to combine Specifications with AND logic [OK]

Common Mistakes:

• Using or() instead of and() for AND condition
• Using non-existent add() or merge() methods
• Not wrapping with Specification.where()