Why Specification pattern for dynamic queries in Spring Boot? - Purpose & Use Cases

The Big Idea

What if you could build any search filter without rewriting your queries every time?

The Scenario

Imagine building a search feature where users can filter products by color, size, price, and availability. You write many if-else checks to add SQL conditions manually for each filter combination.

The Problem

Manually writing queries for every filter combination quickly becomes messy and hard to maintain. Adding a new filter means changing many places, and bugs sneak in easily when conditions overlap or conflict.

The Solution

The Specification pattern lets you build reusable, small query parts that you can combine dynamically. It keeps your code clean and flexible, so adding or changing filters is simple and safe.

Before vs After

✗ Before

if(color != null) query += " AND color = '" + color + "'";
if(size != null) query += " AND size = '" + size + "'";

✓ After

Specification<Product> spec = hasColor(color).and(hasSize(size));
productRepository.findAll(spec);

What It Enables

You can create complex, dynamic database queries by combining simple, reusable specifications without rewriting or duplicating code.

Real Life Example

An online store lets customers filter products by multiple criteria like brand, price range, and ratings. The Specification pattern builds these filters dynamically based on user choices.

Key Takeaways

Manual query building is error-prone and hard to maintain.

Specification pattern breaks queries into reusable parts.

It makes dynamic filtering clean, flexible, and scalable.

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()