Spring Data JDBC

Spring Data JDBC is a lightweight data-access framework from Spring that helps you work with relational databases in a simple, predictable, and SQL-friendly way.

It is designed for developers who want control and clarity, not ORM magic.

---

What Is Spring Data JDBC?

Spring Data JDBC is part of the Spring Data family that allows you to:

• Map Java objects directly to database tables
• Perform CRUD operations easily
• Work with databases using JDBC principles
• Avoid complex ORM behaviors

? In simple words:

Spring Data JDBC = JDBC + Repository abstraction (No ORM)

---

Why Spring Data JDBC?

Spring Data JDBC was introduced to solve issues caused by heavy ORM frameworks like JPA/Hibernate.

Problems with Heavy ORM

• Hidden SQL queries
• Lazy loading confusion
• Unexpected performance issues
• Complex entity lifecycle
• Hard debugging

How Spring Data JDBC Helps

• Explicit SQL behavior
• Predictable execution
• Easy to debug
• No hidden magic

---

Core Philosophy (DDD-Based)

Spring Data JDBC follows Domain-Driven Design (DDD) principles.

Key Rules

• One Aggregate = One Root Entity
• No Lazy Loading
• No Automatic Joins
• One Table = One Entity
• Relationships must be explicit

---

Key Features of Spring Data JDBC

Spring Data JDBC is designed to be simple, explicit, and predictable.

Below is a breakdown of its key features and what they actually mean in practice.

Feature	Spring Data JDBC	Explanation
ORM	No	Not an ORM like JPA/Hibernate; no entity lifecycle or complex mapping.
Lazy Loading	No	All data is fetched immediately; no hidden database calls.
Persistence Context	No	No first-level cache; every operation directly hits the database.
Caching	No	No automatic caching; behavior remains predictable.
SQL Visibility	High	SQL execution is explicit and easy to trace.
CRUD Support	Yes	Built-in CRUD methods via CrudRepository.
Simplicity	Very High	Minimal features, easy to learn, easy to maintain.

---

Basic Architecture

Controller
   ↓
Service
   ↓
Repository (SpringData JDBC)
   ↓
Database

---

Entity Mapping (Basics) in Spring Data JDBC

Spring Data JDBC maps Java objects directly to database tables in a simple and predictable way.

Example Entity

import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Table;

@Table("users")// Maps this class to the "users" table
publicclassUser {

@Id// Primary key
private Long id;

private String name;
private String email;

// Getters and setters
public LonggetId() {return id; }
publicvoidsetId(Long id) {this.id = id; }

public StringgetName() {return name; }
publicvoidsetName(String name) {this.name = name; }

public StringgetEmail() {return email; }
publicvoidsetEmail(String email) {this.email = email; }
}

Important Annotations

Annotation	Purpose
@Table	Maps the class to a specific database table
@Id	Marks the primary key of the table
@Column	Maps a field to a specific column (optional; defaults to field name)

Key Points

• Mapping is direct and explicit; no hidden behavior.
• No proxies or lazy loading.
• Simple, predictable, and easy to debug.

---

Repository Basics

Spring Data JDBC provides repository interfaces to simplify data access. The most common one is CrudRepository, which provides basic CRUD operations out-of-the-box.

Example Repository

import org.springframework.data.repository.CrudRepository;

publicinterfaceUserRepositoryextendsCrudRepository<User, Long> {
// No implementation needed
}

• User → Entity type
• Long → Type of primary key (@Id field)

Common Methods Provided by CrudRepository

Method	Description
save()	Insert or update an entity
findById(ID id)	Retrieve an entity by primary key
findAll()	Retrieve all entities
deleteById(ID id)	Delete entity by primary key

Key Points

• No implementation required: Spring Data JDBC auto-generates the implementation at runtime.
• Provides clean and predictable CRUD operations.
• Works seamlessly with Spring’s DI and transactional support.

---

Saving Data

Useruser=newUser();
user.setName("Amit");
user.setEmail("[email protected]");

// Save entity
userRepository.save(user);

Key Points

• Automatically performs INSERT (new entity) or UPDATE (existing entity based on @Id).
• No persistence context or lazy-loading issues — behavior is explicit and predictable.
• Works seamlessly with Spring’s transaction management.

---

Fetching Data

// Fetch a single user by ID
Optional<User> user = userRepository.findById(1L);

// Fetch all users
Iterable<User> users = userRepository.findAll();

Key Points

• Data is fetched immediately — no lazy loading.
• Returns Optional for single entity to handle null-safety.
• findAll() retrieves all records without proxies or hidden queries.

---

Updating Data

// Fetch user by ID and update
Useruser= userRepository.findById(1L).get();
user.setName("Rahul");
userRepository.save(user);

Key Points

• Performs a full row update.
• No dirty checking or hidden persistence context.
• Explicit and predictable behavior.

---

Deleting Data

// Delete user by ID
userRepository.deleteById(1L);

Key Points

• Simple and explicit deletion.
• No cascading or automatic entity state tracking.

---

Transactions Flow

Explains how transactions work in Spring Data JDBC without persistence context confusion.

Spring Data JDBC integrates seamlessly with Spring’s @Transactional:

@Transactional
publicvoidcreateUser(User user) {
    userRepository.save(user);
}

Key Points

• Straightforward transaction handling.
• No persistence context confusion.
• Works for multiple repository operations within a transaction.

---

Limitations of Spring Data JDBC

Spring Data JDBC does not provide the following features:

• Lazy loading of associations
• Automatic joins between tables
• Entity state tracking (no automatic dirty checking)
• Complex ORM behavior

Developers must explicitly manage queries, relationships, and updates.

---

When to Use Spring Data JDBC

Spring Data JDBC is ideal for scenarios that require simplicity, predictability, and control:

• Microservices and lightweight applications
• Simple CRUD operations
• Performance-critical systems
• Need for full SQL visibility
• Applications that favor explicit, predictable behavior

---

When Not to Use Spring Data JDBC

Avoid using it when your application requires:

• Complex domain models with deep object graphs
• Heavy relationships between entities
• Advanced ORM features such as caching or lazy loading

---

Common Beginner Mistakes

Some frequent pitfalls when starting with Spring Data JDBC:

• Expecting lazy loading like in JPA/Hibernate
• Treating it like a full-fledged JPA implementation
• Designing overly complex entity relationships
• Overusing aggregates beyond what is needed for simplicity

---

Differences Between Spring Data JDBC vs JPA

Feature	Spring Data JDBC	Spring Data JPA	Difference / Notes
ORM	No	Yes	JDBC is simple and works directly with SQL; JPA is a full ORM, mapping objects to tables with complex features.
Lazy Loading	No	Yes	JDBC fetches all data immediately; JPA can defer loading related entities until needed.
Complexity	Low	High	JDBC is straightforward with minimal abstraction; JPA has entity states, persistence context, and caching, making it more complex.
SQL Control	High	Low	JDBC gives full control over SQL; JPA often generates SQL behind the scenes.
Performance Predictability	High	Medium	JDBC is predictable since queries execute exactly as written; JPA performance can vary due to caching, lazy loading, and automatic joins.

---

Conclusion:

Spring Data JDBC is a lightweight, straightforward framework for working with relational databases. It emphasizes simplicity, explicit SQL control, and predictable behavior, making it ideal for microservices and performance-critical applications. Unlike JPA, it avoids hidden complexity like lazy loading, automatic joins, or entity state tracking, allowing developers to write clean, maintainable, and easy-to-debug data access code.