---

JPA Criteria API Interview Questions and Answers

Introduction

The JPA Criteria API is a type-safe, object-oriented way to build dynamic database queries. Unlike JPQL, which is written as strings, Criteria API uses Java objects to construct queries, making them easier to refactor and less prone to runtime syntax errors.

Criteria API is widely used in enterprise applications where search filters are dynamic, such as employee search, product filtering, reporting dashboards, and banking applications.

---

Criteria API Architecture

flowchart LR

Application --> CriteriaBuilder

CriteriaBuilder --> CriteriaQuery

CriteriaQuery --> Hibernate

Hibernate --> SQL

SQL --> Database

---

Q1. What is the Criteria API?

Answer

Criteria API is a type-safe query builder introduced in JPA.

Instead of writing query strings, developers build queries using Java classes.

JPQL

SELECT c FROM Customer c WHERE c.city='Dallas'

Criteria API

CriteriaBuilder cb = entityManager.getCriteriaBuilder();

CriteriaQuery<Customer> query =
cb.createQuery(Customer.class);

Root<Customer> customer =
query.from(Customer.class);

query.select(customer)
.where(cb.equal(customer.get("city"), "Dallas"));

Benefits

• Type-safe
• Dynamic queries
• Easy refactoring
• No string concatenation
• Compile-time validation

---

Q2. What are the main components of Criteria API?

The main building blocks are:

Component	Purpose
CriteriaBuilder	Builds query expressions
CriteriaQuery	Represents SQL query
Root	Main entity
Predicate	WHERE condition
Order	Sorting
TypedQuery	Executes query

Diagram

flowchart TD

CriteriaBuilder --> CriteriaQuery

CriteriaQuery --> Root

Root --> Predicate

Predicate --> TypedQuery

TypedQuery --> Database

---

Q3. What is CriteriaBuilder?

Answer

CriteriaBuilder is a factory used to create query objects and expressions.

Example

CriteriaBuilder cb =
entityManager.getCriteriaBuilder();

It creates

• Equality conditions
• Like conditions
• Greater than
• Less than
• Count
• Sum
• Average
• Order By
• Group By

---

Q4. How do you create a Criteria Query?

Example

CriteriaBuilder cb =
entityManager.getCriteriaBuilder();

CriteriaQuery<Customer> query =
cb.createQuery(Customer.class);

Root<Customer> root =
query.from(Customer.class);

query.select(root);

List<Customer> customers =
entityManager.createQuery(query)
.getResultList();

Equivalent JPQL

SELECT c FROM Customer c

---

Q5. How do WHERE conditions work?

Conditions are created using Predicate.

Example

CriteriaBuilder cb =
entityManager.getCriteriaBuilder();

CriteriaQuery<Customer> query =
cb.createQuery(Customer.class);

Root<Customer> customer =
query.from(Customer.class);

query.where(
cb.equal(
customer.get("city"),
"Dallas"
));

Generated SQL

SELECT *
FROM customers
WHERE city='Dallas'

---

Q6. How do you perform Sorting?

Ascending

query.orderBy(
cb.asc(root.get("name"))
);

Descending

query.orderBy(
cb.desc(root.get("salary"))
);

Generated SQL

ORDER BY salary DESC

---

Q7. How do JOINs work in Criteria API?

Example

Root<Order> order =
query.from(Order.class);

Join<Order,Customer> customer =
order.join("customer");

Diagram

flowchart LR

Order --> Customer

Equivalent JPQL

SELECT o
FROM Order o
JOIN o.customer

---

Q8. How do Dynamic Queries work?

Criteria API shines when search filters are optional.

Example

List<Predicate> predicates =
new ArrayList<>();

if(city != null){

predicates.add(
cb.equal(
root.get("city"),
city
));

}

if(age != null){

predicates.add(
cb.greaterThan(
root.get("age"),
age
));

}

query.where(
predicates.toArray(
new Predicate[0]
));

Benefits

• Flexible
• Dynamic search screens
• Enterprise filtering

---

Q9. How does Pagination work?

Example

TypedQuery<Customer> typedQuery =
entityManager.createQuery(query);

typedQuery.setFirstResult(0);

typedQuery.setMaxResults(20);

Benefits

• Faster
• Less memory
• Better scalability

---

Q10. What are Criteria API Best Practices?

Use Static Metamodel

Instead of

root.get("name")

Prefer

Customer_.name

---

Use Specifications

Spring Data JPA Specifications are built on Criteria API.

Example

Specification<Customer>

---

Keep Queries Modular

Separate predicates into reusable methods.

---

Prefer Criteria API for Dynamic Searches

Use JPQL for simple fixed queries.

Use Criteria API for search screens.

---

Banking Example

flowchart TD

Customer --> Account

Account --> Transaction

Transaction --> CriteriaApi["Criteria API"]

CriteriaApi["Criteria API"] --> SQL

Example filters

• Customer Name
• Account Number
• Date Range
• Status
• Branch
• Transaction Type

Criteria API builds queries dynamically based on selected filters.

---

Common Interview Questions

• What is Criteria API?
• JPQL vs Criteria API?
• What is CriteriaBuilder?
• What is Root?
• What is Predicate?
• How do joins work?
• How do you implement dynamic search?
• How does pagination work?
• What is Specification?
• Why is Criteria API type-safe?

---

Quick Revision

Topic	Description
CriteriaBuilder	Factory for query creation
CriteriaQuery	Represents query
Root	Main entity
Predicate	WHERE condition
Join	Relationship join
Order	Sorting
TypedQuery	Executes query
Pagination	setFirstResult + setMaxResults
Specification	Dynamic query abstraction
Static Metamodel	Compile-time safety

---

Criteria API Execution Flow

sequenceDiagram
Application->>CriteriaBuilder: Build Query
CriteriaBuilder->>CriteriaQuery: Create Query
CriteriaQuery->>Hibernate: Generate SQL
Hibernate->>Database: Execute SQL
Database-->>Hibernate: Result
Hibernate-->>Application: Entity Objects

---

Key Takeaways

• Criteria API provides a type-safe and object-oriented way to build JPA queries.
• It eliminates string-based query errors by using Java classes and methods.
• The core components are CriteriaBuilder, CriteriaQuery, Root, Predicate, and TypedQuery.
• CriteriaBuilder creates query expressions such as equal, like, greaterThan, and aggregate functions.
• Predicate is used to build flexible WHERE conditions.
• Criteria API is ideal for dynamic search screens with optional filters.
• It supports joins, sorting, grouping, pagination, and aggregate functions.
• Spring Data JPA Specifications are built on top of the Criteria API.
• Use JPQL for simple static queries and Criteria API for complex dynamic queries.
• Criteria API is a common enterprise solution for advanced filtering in Spring Boot and Hibernate applications.