Introduction:
In Spring Boot applications, interacting with databases is a fundamental task. Whether you’re fetching data, updating records, or performing complex queries, efficient database operations are crucial for application performance. One powerful tool at your disposal for constructing dynamic queries is the Criteria API, which allows you to build queries programmatically and dynamically based on various criteria.

In this blog post, we’ll explore the Criteria Builder in Spring Boot, from its basic usage to more advanced scenarios, accompanied by practical examples.

Understanding Criteria Builder:
The Criteria API in Spring Boot provides a set of classes and methods to build dynamic queries directly in Java code. It’s particularly useful when you need to construct queries based on dynamic parameters or conditions, rather than writing static SQL queries.

Basic Usage:
Let’s dive into a simple example to understand how Criteria Builder works in Spring Boot:

1. Setup Entity Class:
Assume we have an entity class named Product representing products in our database.

@Entity
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private double price;
// other fields, getters, and setters
}

2. Create a Repository:
We’ll need a repository interface extending JpaRepository to perform database operations.

public interface ProductRepository extends JpaRepository<Product, Long> {
}

3. Implementing a Basic Query:
Now, let’s say we want to fetch all products with a price greater than a certain amount. We can achieve this using Criteria Builder:

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
public class ProductService {
@Autowired
private ProductRepository productRepository;
public List<Product> findProductsByPriceGreaterThan(double minPrice) {
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<Product> query = builder.createQuery(Product.class);
Root<Product> root = query.from(Product.class);
Predicate condition = builder.greaterThan(root.get("price"), minPrice);
query.where(condition);
return entityManager.createQuery(query).getResultList();
}
}

Here, we use CriteriaBuilder to construct a query for fetching products where the price is greater than a specified minimum price.

Medium-Level Usage:
Let’s move on to a slightly more complex scenario where we want to fetch products based on multiple criteria.|

1. Adding Multiple Conditions:
Suppose we want to find products with a price between a certain range and belonging to a specific category.

This method demonstrates how to construct a query with multiple conditions using Criteria Builder.

public List<Product> findProductsByCriteria(double minPrice, double maxPrice, String category) {
CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<Product> query = builder.createQuery(Product.class);
Root<Product> root = query.from(Product.class);
Predicate priceCondition = builder.between(root.get("price"), minPrice, maxPrice);
Predicate categoryCondition = builder.equal(root.get("category"), category);
query.where(builder.and(priceCondition, categoryCondition));
return entityManager.createQuery(query).getResultList();
}

This method demonstrates how to construct a query with multiple conditions using Criteria Builder.

Conclusion:
In this blog post, we’ve covered the basics of using Criteria Builder in Spring Boot for dynamic query construction. From simple queries to more complex ones involving multiple criteria, Criteria Builder provides a powerful and flexible way to interact with databases directly from your Java code. By leveraging Criteria Builder, you can write clean, concise, and maintainable code while effectively querying your database in Spring Boot applications. As you continue to explore and work with Spring Boot, mastering Criteria Builder will undoubtedly enhance your capabilities in database interaction.