Object-Relational Mapping (ORM) with Hibernate

Object-Relational Mapping (ORM) is a programming technique that enables the conversion between data stored in relational databases and the objects used in object-oriented programming languages. Hibernate is a popular Java-based ORM framework that simplifies the interaction between Java applications and relational databases. This guide explores the fundamentals of ORM with Hibernate.

Understanding ORM:

1. Mapping Java Objects to Database Tables:

  • ORM involves mapping Java objects to database tables. Each class in the Java application corresponds to a table in the database, and each instance of the class represents a row in the table.

2. Object Identity and Primary Keys:

  • Objects are identified using primary keys. In Hibernate, the @Id annotation is used to designate a field as the primary key. The @GeneratedValue annotation specifies how the primary key is generated.
@Table(name = "employees")
public class Employee {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "employee_id")
    private Long id;

    // Other fields and methods

3. Associations and Relationships:

  • ORM supports associations and relationships between entities. For example, a Department entity may have a one-to-many relationship with Employee entities.
@Table(name = "departments")
public class Department {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "department_id")
    private Long id;

    @OneToMany(mappedBy = "department")
    private List<Employee> employees;

    // Other fields and methods

4. Mapping Annotations:

  • Hibernate provides a set of annotations to map Java objects to database tables. Common annotations include @Entity, @Table, @Column, @Id, @GeneratedValue, @ManyToOne, @OneToMany, and more.
@Table(name = "students")
public class Student {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "student_id")
    private Long id;

    @Column(name = "name")
    private String name;

    // Other fields and methods

5. Session and SessionFactory:

  • The Session interface in Hibernate represents a single-threaded unit of work. It is used to perform database operations, and it manages the lifecycle of objects.
  • The SessionFactory is a heavyweight object responsible for creating Session instances.
// Creating a SessionFactory
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

// Obtaining a Session
Session session = sessionFactory.openSession();

// Performing database operations using the Session

// Closing the Session

// Closing the SessionFactory

6. CRUD Operations:

  • Hibernate simplifies CRUD operations (Create, Read, Update, Delete) by providing methods in the Session interface.
// Creating (Save)

// Reading (Get)
Employee retrievedEmployee = session.get(Employee.class, 1L);

// Updating (Update)

// Deleting (Delete)

7. Hibernate Query Language (HQL):

  • HQL is a powerful query language provided by Hibernate. It allows developers to write queries using Java objects and properties.
Query query = session.createQuery("FROM Employee WHERE department = :dept");
query.setParameter("dept", department);
List<Employee> employees = query.list();

8. Lazy Loading and Eager Loading:

  • Hibernate supports lazy loading, which defers the loading of related entities until they are explicitly requested. Eager loading, on the other hand, loads related entities immediately.
// Lazy Loading
@OneToMany(mappedBy = "department", fetch = FetchType.LAZY)
private List<Employee> employees;

// Eager Loading
@OneToMany(mappedBy = "department", fetch = FetchType.EAGER)
private List<Employee> employees;

Benefits of ORM with Hibernate:

Abstraction of Database Details:

  • Developers work with high-level objects and do not need to deal with SQL queries or database-specific details.

Improved Productivity:

  • ORM reduces the amount of boilerplate code needed for database operations, leading to increased productivity.


  • Applications become more portable as the underlying database can be changed without affecting the application code.


  • Changes to the database schema do not necessitate changes to the application code, making maintenance more straightforward.

Object-Oriented Paradigm:

  • Developers can work with objects and use the full capabilities of object-oriented programming.

Query Language:

  • HQL provides a convenient and powerful way to query databases using object-oriented syntax.


Hibernate simplifies the interaction between Java applications and relational databases by providing a robust ORM framework. Through the mapping of Java objects to database tables, developers can work with high-level entities, abstracting away the complexities of SQL queries and database interactions. Hibernate’s features, including annotations, associations, lazy loading, and HQL, make it a popular choice for building data-centric Java applications. Understanding ORM with Hibernate is crucial for developers looking to create efficient and maintainable database-driven applications.