WS WhereIsStuff
Tutorial Guides
Log In
Sign Up

Advertisement

Google Ad Slot: content-top

Hibernate Criteria API

Previous Next

The Criteria API is an alternative to HQL (Hibernate Query Language) for writing dynamic queries in Hibernate. Instead of writing queries as plain strings, Criteria API allows type-safe, object-oriented queries.


Why Use Criteria API?

✅ Dynamic Queries – Queries can be built at runtime.

✅ Type-Safe – Uses Java classes instead of raw strings.

✅ No String-Based HQL – Avoids syntax errors from misspelled query strings.

✅ Better Maintainability – Queries are constructed programmatically.

Setting Up Criteria API

To use Criteria API, you need to get a Session and use the CriteriaBuilder class.

HibernateUtil.java
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
private static final SessionFactory sessionFactory = buildSessionFactory();

private static SessionFactory buildSessionFactory() {
try {
return new Configuration()
.configure("hibernate.cfg.xml")
.addAnnotatedClass(Person.class)
.addAnnotatedClass(Course.class)
.buildSessionFactory();
} catch (Throwable ex) {
System.err.println("SessionFactory creation failed: " + ex);
throw new ExceptionInInitializerError(ex);
}
}

public static SessionFactory getSessionFactory() {
return sessionFactory;
}

public static Session getSession() {
return sessionFactory.openSession(); // Opens a new session when needed
}

public static void shutdown() {
sessionFactory.close(); // Close SessionFactory when the application shuts down
}
}
Session session = HibernateUtil.getSession();
CriteriaBuilder builder = session.getCriteriaBuilder();

Fetch All Records (Equivalent to SELECT * FROM table):

Session session = HibernateUtil.getSession();
CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaQuery<Student> query = builder.createQuery(Student.class);
Root<Student> root = query.from(Student.class);
query.select(root);

List<Student> students = session.createQuery(query).getResultList();
System.out.println(students);
session.close();

Applying WHERE Condition

🔹 Fetch Students with Age > 20

🔹 Equivalent SQL: SELECT * FROM student WHERE age > 20;

CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaQuery<Student> query = builder.createQuery(Student.class);
Root<Student> root = query.from(Student.class);
query.select(root).where(builder.gt(root.get("age"), 20));

List<Student> students = session.createQuery(query).getResultList();

Applying Multiple Conditions (AND, OR)

🔹 Fetch Students where age > 20 AND name starts with 'A'

🔹 Equivalent SQL: SELECT * FROM student WHERE age > 20 AND name LIKE 'A%';

CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaQuery<Student> query = builder.createQuery(Student.class);
Root<Student> root = query.from(Student.class);

Predicate agePredicate = builder.gt(root.get("age"), 20);
Predicate namePredicate = builder.like(root.get("name"), "A%");

query.select(root).where(builder.and(agePredicate, namePredicate));

List<Student> students = session.createQuery(query).getResultList();

Sorting Results (ORDER BY)

🔹 Sort Students by Age (Ascending)

🔹 Equivalent SQL: SELECT * FROM student ORDER BY age ASC;


CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaQuery<Student> query = builder.createQuery(Student.class);
Root<Student> root = query.from(Student.class);

query.select(root).orderBy(builder.asc(root.get("age")));

List<Student> students = session.createQuery(query).getResultList();

🔹 Sort Students by Name (Descending)

🔹 Equivalent SQL: SELECT * FROM student ORDER BY name DESC;

query.orderBy(builder.desc(root.get("name")));

Fetching Specific Columns

🔹 Select Only Name and Age

🔹 Equivalent SQL: SELECT name, age FROM student;

CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaQuery<Object[]> query = builder.createQuery(Object[].class);
Root<Student> root = query.from(Student.class);

query.multiselect(root.get("name"), root.get("age"));

List<Object[]> results = session.createQuery(query).getResultList();
for (Object[] row : results) {
System.out.println("Name: " + row[0] + ", Age: " + row[1]);
}

Aggregation Functions (COUNT, SUM, AVG, MIN, MAX)

🔹 Count Total Students

🔹 Equivalent SQL: SELECT COUNT(*) FROM student;

CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaQuery<Long> query = builder.createQuery(Long.class);
Root<Student> root = query.from(Student.class);

query.select(builder.count(root));

Long count = session.createQuery(query).getSingleResult();
System.out.println("Total Students: " + count);

🔹 Find Average Age

🔹 Equivalent SQL: SELECT AVG(age) FROM student;

query.select(builder.avg(root.get("age")));

Using Joins in Criteria API

🔹 Inner Join (Fetch Students with their Courses)

🔹 Equivalent SQL: SELECT * FROM student JOIN course ON student.id = course.student_id;

CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaQuery<Student> query = builder.createQuery(Student.class);
Root<Student> root = query.from(Student.class);

Join<Student, Course> courseJoin = root.join("courses"); // Assuming 'courses' is a List<Course>
query.select(root);

List<Student> students = session.createQuery(query).getResultList();

🔹 Left Join (Fetch Students Even If They Have No Courses)

🔹 Equivalent SQL: SELECT * FROM student LEFT JOIN course ON student.id = course.student_id;

Join<Student, Course> courseJoin = root.join("courses", JoinType.LEFT);

Pagination (Limit & Offset)

Hibernate Criteria API allows pagination using setFirstResult() and setMaxResults().

🔹 Fetch Page 2 (5 Records Per Page)

🔹 Equivalent SQL: SELECT * FROM student LIMIT 5 OFFSET 5;

List<Student> students = session.createQuery(query)
.setFirstResult(5) // Skip first 5 records (Page 2)
.setMaxResults(5) // Fetch next 5 records
.getResultList();

Deleting Data using Criteria API

🔹 Equivalent SQL: DELETE FROM student WHERE name = 'John';

CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaDelete<Student> deleteQuery = builder.createCriteriaDelete(Student.class);
Root<Student> root = deleteQuery.from(Student.class);

deleteQuery.where(builder.equal(root.get("name"), "John"));

session.beginTransaction();
int deletedCount = session.createQuery(deleteQuery).executeUpdate();
session.getTransaction().commit();

Updating Data using Criteria API

🔹 Equivalent SQL: UPDATE student SET age = 25 WHERE name = 'Alice';

CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaUpdate<Student> updateQuery = builder.createCriteriaUpdate(Student.class);
Root<Student> root = updateQuery.from(Student.class);

updateQuery.set("age", 25).where(builder.equal(root.get("name"), "Alice"));

session.beginTransaction();
int updatedCount = session.createQuery(updateQuery).executeUpdate();
session.getTransaction().commit();

Previous Next