ORM (Object-Relational Mapping)

ORM (Object-Relational Mapping) is a programming technique that allows developers to interact with a relational database using objects and classes instead of writing raw SQL queries.

ORM acts as a bridge between object-oriented programming (OOP) and relational databases, automatically handling the conversion between Java objects and database tables.

---

What is ORM?

ORM automatically maps:

• Java Classes → Database Tables
• Object Fields → Table Columns
• Objects → Rows
• Object Relationships → Table Relationships
• Database Rows → Java Objects

This means developers focus on business logic, while ORM handles SQL generation and data mapping internally.

? In simple words:

ORM lets you work with the database using objects, not SQL.

---

Why ORM is Needed

Without ORM, developers must:

• Write SQL queries manually
• Convert ResultSet into Java objects
• Handle joins and relationships manually
• Manage transactions and database connections
• Maintain large amounts of boilerplate code

ORM automates all of this, making applications cleaner, safer, and easier to maintain.

---

How ORM Works

1. You define an Entity class using annotations.
2. ORM maps the class to a database table.
3. When you call repository methods:
   • ORM generates SQL automatically
   • Executes the query on the database
   • Maps the result back to Java objects

Java Object
   ↓
ORM Framework (Hibernate)
   ↓
SQL Query
   ↓
Database
   ↓
Table Rows
   ↓
Java Objects

---

Example

This example demonstrates how ORM maps a Java entity to a database table and eliminates the need for manual SQL and result mapping.

Entity Class (With ORM)

Defines a Java class as a database entity using JPA annotations, allowing ORM to handle table mapping automatically.

import jakarta.persistence.*;

@Entity
@Table(name = "users")
publicclassUser {

@Id
@GeneratedValue
private Long id;

private String name;
private String email;
}

---

Database Table

Represents how the ORM-mapped entity is stored in the relational database.

users
-----------------
id | name | email

---

Example Without ORM (JDBC)

Shows how data must be fetched and mapped manually when ORM is not used.

Stringsql="SELECT * FROM users WHERE id = ?";
PreparedStatementps= conn.prepareStatement(sql);
ps.setLong(1,1);

ResultSetrs= ps.executeQuery();

Useruser=newUser();
user.setId(rs.getLong("id"));
user.setName(rs.getString("name"));

---

Example With ORM (Spring Data JPA + Hibernate)

Demonstrates how ORM retrieves database records using repository methods without writing SQL.

Useruser= userRepository.findById(1L).get();

---

Key Concepts in ORM

Concept	Description
Entity	Java class that represents a database table
Mapping	Links entity fields to table columns
EntityManager / Session	Manages the lifecycle and persistence of entities
Relationships	Defines associations like One-to-One, One-to-Many, Many-to-One
Lazy Loading	Fetches related data only when it is accessed
Caching	Stores data temporarily to improve performance
Transactions	Ensures database operations are completed reliably and consistently

---

Popular ORM Frameworks

Java Ecosystem

• Hibernate – Most widely used ORM framework in Java
• EclipseLink – Official JPA reference implementation
• OpenJPA – Lightweight and flexible JPA implementation

Other Languages

• Spring (Java): Spring Data JPA – Repository abstraction over JPA
• Python: Django ORM, SQLAlchemy – Object-based database access
• .NET: Entity Framework – ORM for .NET applications
• JavaScript: Sequelize, TypeORM – ORM for Node.js environments

---

ORM in Spring Boot

Spring Boot integrates ORM using Spring Data JPA and Hibernate.

Spring Data JPA
      ↓
Hibernate (ORM Engine)
      ↓
Database

• Spring Data JPA provides repository abstraction and query support
• Hibernate handles object-relational mapping, SQL generation, caching, and lazy loading

---

ORM vs JDBC

Feature	ORM (Hibernate / JPA)	JDBC
SQL Writing	Very little SQL is needed; ORM generates queries automatically	Developers must write SQL manually
Data Mapping	Automatic mapping between objects and tables	Manual mapping using ResultSet and Java objects
Relationships	Easy to manage using annotations like @OneToMany	Complex and fully manual joins
Lazy Loading	Supported for optimized data fetching	Not supported
Maintainability	High, cleaner and more readable code	Low, more boilerplate and repetitive code
Performance	Medium, with some abstraction overhead	High when queries are carefully optimized

---

Advantages of ORM

• Reduces boilerplate code
• Produces clean and readable code
• Enables object-oriented database access
• Automatically handles entity relationships
• Provides built-in caching support
• Simplifies transaction management
• Speeds up application development

---

Disadvantages of ORM

• Has a learning curve for beginners
• Offers less direct control over SQL queries
• May introduce performance overhead for complex queries
• Not suitable for heavy reporting or analytics systems

---

When to Use ORM

Use ORM when:

• The application has complex domain models
• Entity relationships play an important role
• Code maintainability is a priority
• Rapid development and scalability are required
• The application is enterprise-level

Avoid ORM when:

• The application is very simple
• Performance requirements are extremely strict
• Heavy analytics or highly optimized SQL queries are needed
• Microservices require minimal runtime overhead

---

Real-World ORM Example

E-commerce Application

User → Orders → OrderItems

This structure represents a typical real-world domain model with multiple related entities.

ORM automatically handles database operations such as joins, relationships, lazy loading, and cascading actions without requiring manual SQL.

---

Conclusion

ORM (Object-Relational Mapping) bridges the gap between object-oriented programming and relational databases.

It allows developers to:

• Work with databases using objects
• Write minimal SQL
• Build clean, maintainable, and scalable applications

In Spring Boot, Spring Data JPA + Hibernate is the most widely used ORM solution for enterprise-grade applications.