Hibernate Introduction and Architecture

With plain JDBC, every table needs hand-written SQL and manual code to copy each ResultSet row into a Java object — repetitive, easy to get wrong, and tedious to keep in sync as a schema evolves. Hibernate is an Object-Relational Mapping (ORM) framework: you describe how a Java class maps to a database table once, and Hibernate generates the SQL for you, tracks which objects have changed, and handles relationships, caching, and lazy loading automatically.

Hibernate implements the JPA (Java Persistence API) specification and sits on top of JDBC — it still ultimately opens a JDBC Connection and runs SQL, but your application code works with plain Java objects ("entities") instead of raw rows and columns.

The Core Architecture

Four objects cooperate to move data between your Java objects and the database.

• Configuration — reads hibernate.cfg.xml (or Spring Boot properties) to learn the database connection details, dialect, and which classes are mapped entities.
• SessionFactory — a heavyweight, thread-safe object built once per application from the Configuration; it is expensive to create, so you build exactly one and reuse it for the life of the app.
• Session — a lightweight, single-threaded unit of work opened from the SessionFactory for each logical operation (e.g. one request); it wraps a JDBC connection and is not safe to share across threads.
• Transaction — wraps one or more operations on a Session so they commit or roll back together.

Entities and the Persistence Context

A class annotated @Entity maps to a table; its fields map to columns. Once an object is loaded or saved through a Session, it becomes managed — Hibernate keeps it in the Session's first-level cache (the "persistence context") and automatically detects field changes, writing the necessary UPDATE statement when the transaction commits, without you calling any explicit "save changes" method.

Hibernate vs. Plain JDBC

JDBC gives full control over SQL but requires manual mapping and manual change-tracking. Hibernate trades a little of that control for dramatically less boilerplate: relationships, inheritance, caching, and dirty-checking are handled by the framework. Most production Spring applications use Hibernate through Spring Data JPA (see the Spring Boot and REST APIs module), which adds repository interfaces on top of the same underlying Hibernate engine.

Example

<!-- hibernate.cfg.xml -->
<hibernate-configuration>
  <session-factory>
    <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/school</property>
    <property name="hibernate.connection.username">root</property>
    <property name="hibernate.connection.password">password</property>
    <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    <property name="hibernate.hbm2ddl.auto">update</property>
    <mapping class="com.webnest.Student"/>
  </session-factory>
</hibernate-configuration>

// Student.java
import jakarta.persistence.*;

@Entity
@Table(name = "student")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "name", nullable = false)
    private String name;

    private int marks;

    // getters and setters
}

// Startup log (abridged):
Hibernate: create table student (id integer not null auto_increment, name varchar(255) not null, marks integer, primary key (id))

Exercise

A teammate is about to make this mistake: Creating a new SessionFactory for every request — it is expensive to build and is meant to be created once and reused for the application's lifetime. Use The Core Architecture to review the decision. Write a corrected implementation or design sketch that follows Hibernate is an ORM: it maps Java classes to tables and generates SQL automatically., then name one edge case you would check.

Quick quiz

Interview questions