What You Will Learn

• What is Spring JDBC?
• What is JPA?
• Architecture Comparison
• CRUD Examples
• Performance Comparison
• Enterprise Use Cases
• When to Use Spring JDBC
• When to Use JPA
• Banking Examples
• Interview Questions

---

Introduction

Most Java applications need to interact with databases.

Popular approaches:

Spring JDBC

Spring Data JPA

Question:

Which one should I use?

Which is faster?

Which is easier?

Which is better for enterprise systems?

Let's understand in depth.

---

Evolution of Database Access

JDBC

↓

Spring JDBC

↓

Hibernate

↓

JPA

↓

Spring Data JPA

Each layer reduces boilerplate code.

---

What is Spring JDBC?

Spring JDBC is a lightweight wrapper around JDBC.

Spring removes:

Connection Management

Resource Cleanup

Exception Handling

Boilerplate Code

But you still write SQL.

---

Spring JDBC Architecture

flowchart LR

A[Application]

B[Spring JDBC]

C[JDBC Driver]

D[Database]

A --> B
B --> C
C --> D

---

What is JPA?

JPA stands for:

Java Persistence API

JPA is a specification.

Popular implementation:

Hibernate

Instead of writing SQL:

You work with Java Objects

---

JPA Architecture

flowchart LR

A[Application]

B[Spring Data JPA]

C[Hibernate]

D[JDBC]

E[Database]

A --> B
B --> C
C --> D
D --> E

---

Core Difference

Spring JDBC:

You Write SQL

JPA:

You Work With Objects

---

Example Table

CREATE TABLE USERS(

 ID BIGINT PRIMARY KEY,

 NAME VARCHAR(100),

 EMAIL VARCHAR(100)

);

---

Spring JDBC CRUD Example

Entity

public class User {

    private Long id;

    private String name;

    private String email;

}

---

Repository

@Repository
public class UserRepository {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List<User> findAll() {

        return jdbcTemplate.query(
            "SELECT * FROM USERS",
            (rs,rowNum) -> {

                User user = new User();

                user.setId(
                    rs.getLong("id")
                );

                user.setName(
                    rs.getString("name")
                );

                user.setEmail(
                    rs.getString("email")
                );

                return user;
            }
        );
    }
}

---

Spring JDBC Flow

flowchart LR

A[Service]

B[JdbcTemplate]

C[SQL Query]

D[Database]

A --> B
B --> C
C --> D

---

JPA CRUD Example

Entity

@Entity
@Table(name="USERS")
public class User {

    @Id
    private Long id;

    private String name;

    private String email;
}

---

Repository

@Repository
public interface UserRepository
extends JpaRepository<User,Long> {

}

---

Service

List<User> users =
    repository.findAll();

No SQL required.

---

JPA Flow

flowchart LR

A[Service]

B[JpaRepository]

C[Hibernate]

D[JDBC]

E[Database]

A --> B
B --> C
C --> D
D --> E

---

Insert Example

Spring JDBC

jdbcTemplate.update(

"INSERT INTO USERS(ID,NAME,EMAIL)

VALUES(?,?,?)",

1L,

"John",

"[email protected]"

);

---

JPA Insert

User user = new User();

user.setId(1L);

user.setName("John");

user.setEmail("[email protected]");

repository.save(user);

Much simpler.

---

Update Example

Spring JDBC

jdbcTemplate.update(

"UPDATE USERS

SET NAME=?

WHERE ID=?",

"David",

1L

);

---

JPA

User user =
repository.findById(1L)
          .get();

user.setName("David");

repository.save(user);

---

Delete Example

Spring JDBC

jdbcTemplate.update(

"DELETE FROM USERS

WHERE ID=?",

1L

);

---

JPA

repository.deleteById(1L);

---

Query Example

Spring JDBC

jdbcTemplate.query(

"SELECT * FROM USERS

WHERE NAME=?",

mapper,

"John"

);

---

JPA

List<User> users =
repository.findByName(
"John"
);

---

Code Comparison

Spring JDBC

SQL Required

RowMapper Required

Manual Mapping

---

JPA

Entity Mapping

Repository

Automatic SQL Generation

---

Performance Comparison

Generally:

Spring JDBC

↓

Faster

because:

No ORM Layer

No Entity Management

No Dirty Checking

---

Why JPA Is Slower?

JPA performs:

Entity Tracking

Caching

Lazy Loading

Dirty Checking

Relationship Management

Additional overhead.

---

Performance Architecture

flowchart LR

A[Spring JDBC]

B[Database]

A --> B

Direct communication.

---

flowchart LR

A[JPA]

B[Hibernate]

C[JDBC]

D[Database]

A --> B
B --> C
C --> D

Additional layers.

---

Development Speed

Spring JDBC:

Write SQL

Write Mapping

Write Repository

More effort.

---

JPA

Entity

Repository

Done

Faster development.

---

Complex Queries

Consider:

15 Table Join

Aggregation

Window Functions

CTE Queries

---

Winner?

Spring JDBC

Reason:

Full SQL Control

---

Banking Example

Fund Transfer System.

Tables:

ACCOUNT

TRANSACTION

CUSTOMER

---

Banking Queries

Complex reports:

Monthly Statements

Fraud Reports

Audit Reports

Best choice:

Spring JDBC

---

Banking CRUD

Simple operations:

Create Account

Update Customer

Get Balance

Best choice:

JPA

---

Real Enterprise Architecture

flowchart LR

A[REST API]

B[Service Layer]

C[JPA Repository]

D[Database]

A --> B
B --> C
C --> D

Common architecture.

---

Enterprise Hybrid Approach

Most enterprise systems use:

JPA

+

Spring JDBC

together.

---

Example

Use JPA for:

CRUD

Master Data

Customer Data

Use JDBC for:

Reports

Batch Jobs

Analytics Queries

---

Hybrid Architecture

flowchart LR

A[Service Layer]

B[JPA Repository]

C[JdbcTemplate]

D[Database]

A --> B
A --> C

B --> D
C --> D

---

When To Use Spring JDBC

Use when:

Complex SQL

Bulk Processing

Large Reports

Stored Procedures

Performance Critical Systems

---

When To Use JPA

Use when:

CRUD Applications

Rapid Development

Microservices

REST APIs

Domain Driven Design

---

Batch Processing Example

Processing:

10 Million Records

Preferred:

Spring JDBC

Reason:

Lower Memory Usage

---

Microservices Example

Typical Microservice:

Customer Service

Product Service

Order Service

Preferred:

Spring Data JPA

Reason:

Fast Development

---

Pros of Spring JDBC

✅ Maximum Performance

✅ Full SQL Control

✅ Easy Query Optimization

✅ Great For Batch Jobs

✅ Stored Procedure Support

---

Cons of Spring JDBC

❌ More Code

❌ Manual Mapping

❌ SQL Maintenance

❌ Slower Development

---

Pros of JPA

✅ Less Code

✅ Automatic CRUD

✅ Faster Development

✅ Relationship Management

✅ Caching Support

---

Cons of JPA

❌ ORM Overhead

❌ Hidden SQL

❌ N+1 Problems

❌ Lazy Loading Issues

❌ Performance Tuning Required

---

Spring JDBC vs JPA

Feature	Spring JDBC	JPA
SQL Writing	Yes	No
Performance	Excellent	Good
Development Speed	Medium	Excellent
Complex Queries	Excellent	Good
Batch Jobs	Excellent	Medium
CRUD APIs	Medium	Excellent
Learning Curve	Easy	Medium

---

Interview Questions

Is JPA Faster Than JDBC?

No.

JDBC is generally faster.

---

Why Use JPA Then?

Faster development and less code.

---

What Uses JDBC Internally?

Hibernate

Spring Data JPA

Everything eventually reaches JDBC.

---

Can We Use Both Together?

Yes.

Most enterprise applications do.

---

Best Choice For Batch Processing?

Spring JDBC

---

Best Choice For CRUD APIs?

Spring Data JPA

---

Key Takeaways

• Spring JDBC is a lightweight abstraction over JDBC.
• JPA is an ORM abstraction built on top of Hibernate and JDBC.
• JDBC provides maximum performance and SQL control.
• JPA provides faster development and cleaner code.
• Most enterprise systems use both together.
• Use JPA for CRUD-heavy applications.
• Use Spring JDBC for reporting, batch jobs, and performance-critical queries.

---