# Hibernate ORM — The Standard Java Persistence Framework

> Hibernate is the most widely used ORM for Java and Kotlin, implementing the Jakarta Persistence (JPA) specification to map objects to relational databases with transparent persistence.

## Install

Save in your project root:

# Hibernate ORM — The Standard Java Persistence Framework

## Quick Use
```xml
<!-- Maven dependency -->
<dependency>
  <groupId>org.hibernate.orm</groupId>
  <artifactId>hibernate-core</artifactId>
  <version>6.6.0.Final</version>
</dependency>
```
```java
// Annotate entities and use EntityManager
@Entity class User {
  @Id @GeneratedValue Long id;
  String name;
}
```

## Introduction
Hibernate ORM is the reference implementation of the Jakarta Persistence API (JPA). It handles object-relational mapping, query generation, caching, and transaction management, letting developers work with Java objects while Hibernate translates operations to SQL for any supported database.

## What Hibernate Does
- Maps Java/Kotlin classes to database tables using annotations or XML
- Generates optimized SQL from HQL, JPQL, and Criteria API queries
- Manages entity lifecycle with dirty checking and automatic flush on commit
- Provides first-level (session) and second-level (shared) caching
- Supports lazy loading, batch fetching, and join strategies for associations

## Architecture Overview
Hibernate sits between application code and JDBC. A SessionFactory is built from mapping metadata and configuration, producing lightweight Session instances per unit of work. The Session acts as a first-level cache and identity map. On flush, dirty checking compares entity snapshots and generates minimal SQL DML. The query engine parses HQL/JPQL into an AST, applies optimizations, and delegates to a Dialect class that emits database-specific SQL. Second-level cache integrates with providers like Infinispan or EHCache.

## Self-Hosting & Configuration
- Add hibernate-core and a JDBC driver to your Maven or Gradle project
- Configure via `persistence.xml` (JPA) or `hibernate.cfg.xml` with connection details
- Use Spring Boot's `spring-boot-starter-data-jpa` for auto-configuration
- Set `hibernate.hbm2ddl.auto` to `validate` in production, `update` in development
- Enable statistics and slow query logging with `hibernate.generate_statistics=true`

## Key Features
- Automatic schema generation and validation from entity mappings
- HQL and Criteria API enable type-safe, database-portable queries
- Batch insert/update support with configurable JDBC batch sizes
- Multi-tenancy support with schema-based, database-based, or discriminator strategies
- Hibernate Reactive provides non-blocking database access with Vert.x

## Comparison with Similar Tools
- **MyBatis** — SQL-centric mapper; Hibernate provides full object-lifecycle management
- **jOOQ** — Typesafe SQL DSL; Hibernate abstracts SQL with entity-level operations
- **EclipseLink** — Alternative JPA implementation; Hibernate has broader community adoption
- **Entity Framework Core** — .NET equivalent; Hibernate is the Java ecosystem standard
- **Spring Data JPA** — Repository abstraction layer; uses Hibernate as the default JPA provider

## FAQ
**Q: What is the N+1 query problem in Hibernate?**
A: Accessing lazy collections in a loop fires one query per entity. Fix with `JOIN FETCH`, `@BatchSize`, or entity graphs.

**Q: Should I use Hibernate or plain JDBC?**
A: Hibernate reduces boilerplate for CRUD-heavy apps. For complex analytical queries or minimal overhead, JDBC or jOOQ may be better.

**Q: Does Hibernate support reactive/non-blocking access?**
A: Yes. Hibernate Reactive works with Vert.x and non-blocking JDBC drivers for reactive applications.

**Q: How do I migrate from Hibernate 5 to 6?**
A: Update the namespace from javax.persistence to jakarta.persistence, review removed deprecated APIs, and test query behavior changes.

## Sources
- https://github.com/hibernate/hibernate-orm
- https://hibernate.org/orm/documentation/

---
Source: https://tokrepo.com/en/workflows/asset-85fc32f9
Author: AI Open Source