Get List of Entity From Database in Hibernate

1. Introduction

Hibernate is a powerful ORM (Object-Relational Mapping) framework that simplifies the interaction between Java objects and relational databases. Hibernate abstracts away the complexities of writing raw SQL queries, enabling us to retrieve lists of entities using a more object-oriented approach. In this tutorial, we’ll explore a few techniques for retrieving lists of entities from a database using Hibernate.

2. Mapping Database Tables to Entities

Hibernate provides a straightforward way to map database tables to Java classes, known as entities. Each entity class represents a table in the database, with attributes mapping to columns in the table. Annotations such as @Entity, @Table, @Id, and @Column are used to define the mapping between the Java class and the corresponding database table.

Moreover, Hibernate leverages entity mappings to translate our queries (using JPQL or Criteria API) into efficient SQL statements. When we write a JPQL query like “SELECT e FROM Employee e“, Hibernate understands that “Employee” refers to the entity class representing our “Employee” table and “e” represents an instance of that entity. It then translates this into the appropriate SQL statement to retrieve data from the underlying database table.

3. Using Criteria API

The Criteria API provides an alternative for building queries programmatically using Java objects. It allows us to construct queries dynamically at runtime, which can be particularly useful when the query criteria are not known at compile time or need to be built dynamically based on user input or application logic.

Here’s how to retrieve a list of entities using the Criteria API:

@PersistenceContext
private EntityManager entityManager;
public List<Employee> getAllEmployees() {
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Employee> criteriaQuery = criteriaBuilder.createQuery(Employee.class);
    Root<Employee> employeeRoot = criteriaQuery.from(Employee.class);
    criteriaQuery.select(employeeRoot);
    Query query = entityManager.createQuery(criteriaQuery);
    return query.getResultList();
}

This example retrieves all Employee entities. CriteriaBuilder is used to construct the query. We define the root entity (Employee.class) and specify that we want to select all attributes (criteriaQuery.select(employeeRoot)) from this entity. Finally, the query is converted to a typed Query object and executed using getResultList().

The Criteria API allows for building dynamic filtering and sorting criteria. Here’s an example of retrieving employees from the “Engineering” department sorted by last name in ascending order:

public List<Employee> getAllEmployeesByDepartment(String department) {
    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<Employee> criteriaQuery = criteriaBuilder.createQuery(Employee.class);
    Root<Employee> employeeRoot = criteriaQuery.from(Employee.class);
    Predicate departmentPredicate = criteriaBuilder.equal(employeeRoot.get("department"), department);
    Path<Object> sortByPath = employeeRoot.get("lastName");
    criteriaQuery.orderBy(criteriaBuilder.asc(sortByPath));
    criteriaQuery.select(employeeRoot).where(departmentPredicate);
    Query query = entityManager.createQuery(criteriaQuery);
    return query.getResultList();
}

This example defines a departmentPredicate using the criteriaBuilder.equal() method and applies it to the query. The sorting by last name is achieved using criteriaBuilder.asc().

4. Using JPQL (Java Persistence Query Language)

JPQL offers a convenient way to write queries that resemble SQL syntax but operate on entity and attribute names instead of tables and columns. This simplifies query construction and improves readability.

Here’s how to retrieve all Employee entities using JPQL:

@PersistenceContext
private EntityManager entityManager;
public List<Employee> getAllEmployees() {
    String jpqlQuery = "SELECT e FROM Employee e";
    Query query = entityManager.createQuery(jpqlQuery, Employee.class);
    return query.getResultList();
}

We construct a JPQL query string SELECT e FROM Employee e to retrieve all Employee entities. Next, we use the createQuery() method of EntityManager to create a JPQL query object and set the query string and the expected result type (Employee.class). Finally, we execute the query using the getResultList() method, which returns a list of Employee entities fetched from the database.

JPQL offers functionalities for filtering results using a WHERE clause and sorting them using ORDER BY. Here’s an example demonstrating how to retrieve employees from a specific department sorted by last name in ascending order:

public List<Employee> getAllEmployeesByDepartment() {
    String jpqlQuery = "SELECT e FROM Employee e WHERE e.department = 'Engineering' ORDER BY e.lastName ASC"; 
    Query query = entityManager.createQuery(jpqlQuery, Employee.class); 
    return query.getResultList();
}

This query retrieves all Employee entities (e) where the department attribute equals “Engineering” and sorts them by their lastName attribute in ascending order (ASC).

5. Using Named Queries

While JPQL offers a convenient way to construct queries dynamically, named queries provide a structured approach for pre-defining reusable queries within our entity classes or a separate XML configuration file. This improves code readability and maintainability and reduces the risk of errors in query strings.

There are two primary methods for defining named queries in Hibernate.

5.1. Using Annotations

We can define a named query using the @NamedQuery annotation directly within our entity class:

@Entity
@NamedQuery(name = "findAllEmployees", query = "SELECT e FROM Employee e")
@NamedQuery(name = "findEmployeesByDepartment", query = "SELECT e FROM Employee e WHERE e.department = :department ORDER BY e.lastName ASC")
public class Employee {
    @Id
    @GeneratedValue
    private Integer id;
    private String lastName;
    private String department;
    // getter and setter methods
}

In this example, we define two named queries within the Employee entity class using the @NamedQuery annotation. The first named query, findAllEmployees, retrieves all employees from the database without any filtering criteria.

The second named query, findEmployeesByDepartment, is more specific. It retrieves employees based on their associated department. By providing the department as a parameter (:department), we can filter the employees based on the specified department. Additionally, the query sorts the results by the employees’ last names in ascending order (ORDER BY e.lastName ASC).

5.2. Using XML Configuration

We can create an XML file hibernate.cfg.xml to define named queries. We use the <named-query> element to specify the query name, JPQL string, and target entity:

<hibernate-configuration>
    <named-query name="findAllEmployees">
        <query>SELECT e FROM Employee e</query>
    </named-query>
    <named-query name="findEmployeesByDepartment">
        <query>SELECT e FROM Employee e WHERE e.department = :department ORDER BY e.lastName ASC</query>
    </named-query>
</hibernate-configuration>

This configuration defines the same two named queries (findAllEmployees and findEmployeesByDepartment) as in the annotation approach. XML configuration offers greater separation of concerns and centralized management, while annotations provide a more concise and entity-centric way to define named queries.

5.3. Utilizing Named Queries

To use a named query, we can use the entityManager.createNamedQuery() method. This method allows us to create and execute a named query defined within an entity class or XML configuration.

Here’s a code snippet demonstrating the usage of a named query:

@PersistenceContext
private EntityManager entityManager;
public List<Employee> getAllEmployees() {
    Query query = entityManager.createNamedQuery("findAllEmployees", Employee.class);
    return query.getResultList();
}
public List<Employee> findEmployeesByDepartment(String department) {
    Query query = entityManager.createNamedQuery("findEmployeesByDepartment", Employee.class);
    query.setParameter("department", department);
    return query.getResultList();
}

In this example, we retrieve all employees (findAllEmployees) and filter them by department (findEmployeesByDepartment) using named queries.

6. One-to-Many Relationship

In Hibernate, we can easily access the collection of associated entities from the parent entity using the getter method. The one-to-many relationships allow a single entity (parent) to be associated with a collection of related entities (children). This functionality is particularly useful when retrieving lists of parent entities, as we might also want to access their associated child entities in a single query.

Here’s a code example demonstrating how to retrieve a list of Department entities along with their associated Employee entities using the getEmployees() method:

@Entity
public class Department {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    <span class="citation-0 citation-end-0">@OneToMany(mappedBy = "department",</span> fetch = FetchType.EAGER)
    private List<Employee> employees;
    // Getters and setters...
}

In this mapping configuration, the Department entity has a OneToMany association with the Employee entity, mapped by the department field in the Employee entity. The employees field in the Department entity represents the collection of associated employees.

Now, we can directly access the collection of employees for a specific department using the getEmployees() method:

public List<Employee> getAllEmployeesByDepartment(String departmentName) {
    Department department = entityManager.createQuery("SELECT d FROM Department d WHERE d.name = :name", Department.class)
      .setParameter("name", "Engineering")
      .getSingleResult();
    return department.getEmployees();
}

In this example, the @OneToMany annotation on the employees field utilizes fetch = FetchType.EAGER. This instructs Hibernate to retrieve all associated Employee and Department entities in a single query.

7. Conclusion

In this article, we’ve explored various approaches for retrieving lists of entities using Hibernate: JPQL, Criteria API, and one-to-many relationships. JPQL provides a straightforward and intuitive way to construct queries, making it suitable for basic queries or those with known criteria. However, Criteria API can be useful, particularly in scenarios where query criteria are not known at compile time or need to be dynamically adjusted based on application logic or user input.

As always, the source code for the examples is available over on GitHub.