Specification pattern for dynamic queries in Spring Boot - Step-by-Step Execution

Concept Flow - Specification pattern for dynamic queries

Start: Receive filter criteria

↓

Create Specification objects

↓

Combine Specifications with AND/OR

↓

Pass Specification to Repository

↓

Repository builds query dynamically

↓

Execute query and return results

↓

End

The flow starts with filter criteria, builds Specification objects, combines them, passes to repository which creates and runs the query dynamically.

Execution Sample

Spring Boot

Specification<Person> spec = where(nameContains("John"))
  .and(ageGreaterThan(25));
List<Person> results = personRepository.findAll(spec);

This code creates a Specification to find people named John older than 25, then fetches matching results.

Execution Table

Step	Action	Specification State	Query Part	Result
1	Call nameContains("John")	Spec: name like '%John%'	WHERE name LIKE '%John%'	Spec created
2	Call ageGreaterThan(25)	Spec: age > 25	AND age > 25	Spec created
3	Combine with AND	Spec: name like '%John%' AND age > 25	WHERE name LIKE '%John%' AND age > 25	Combined Spec
4	Pass Spec to repository	Spec ready	Query built dynamically	Query ready
5	Execute query	Spec unchanged	Query runs	List<Person> returned
6	End	Spec unchanged	Query complete	Results delivered

💡 Query executes after combining all Specifications and returns matching results.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	Final
spec	null	nameContains("John") Spec	ageGreaterThan(25) Spec separate	Combined Spec with AND	Passed to repo	Used in query	Unchanged

Key Moments - 3 Insights

How do multiple Specifications combine to form one query?

They combine using logical operators like AND or OR, as shown in step 3 of the execution_table where two specs merge into one combined spec.

Does the Specification execute the query by itself?

No, the Specification only builds the query conditions. The repository executes the query as shown in step 5.

Can Specifications be reused or combined dynamically?

Yes, Specifications are modular and can be combined dynamically before passing to the repository, demonstrated in steps 1-3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the Specification state after step 3?

A Spec: name like '%John%' OR age > 25

B Spec: age > 25 only

C Spec: name like '%John%' AND age > 25

D Spec: name like '%John%' only

💡 Hint

Check the 'Specification State' column at step 3 in the execution_table.

At which step does the repository build the query dynamically?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'Query Part' column to find when 'Query built dynamically' happens.

If we add another Specification with OR instead of AND, how would the combined Specification state change at step 3?

A Spec: name like '%John%' AND age > 25

B Spec: name like '%John%' OR age > 25

C Spec: name like '%John%' only

D Spec: age > 25 only

💡 Hint

Think about how logical operators combine Specifications as shown in step 3.

Concept Snapshot

Specification pattern builds reusable query conditions.
Combine Specifications with AND/OR to form complex queries.
Pass combined Specification to Spring Data repository.
Repository dynamically builds and runs the query.
Allows flexible, dynamic filtering without hardcoding queries.

Full Transcript

The Specification pattern in Spring Boot helps build dynamic database queries by creating small reusable conditions called Specifications. Each Specification represents a filter, like 'name contains John' or 'age greater than 25'. These Specifications can be combined using logical operators like AND or OR to form complex queries. The combined Specification is then passed to the repository, which builds the actual database query dynamically and executes it. This approach avoids hardcoding queries and allows flexible filtering based on user input or other criteria. The execution flow starts with creating Specifications, combining them, passing to the repository, and finally executing the query to get results.

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