Repository Pattern in Java

Learn Repository Pattern in Java with Spring Data JPA, CRUD operations, database abstraction, enterprise architecture, UML diagrams, code examples, and interview questions.

What You Will Learn

What is Repository Pattern?
Why Repository Pattern is Needed
DAO vs Repository
Database Abstraction
Spring Data JPA
CRUD Operations
Enterprise Architecture
Benefits and Limitations
Interview Questions

Introduction

Every enterprise application needs data access.

Examples:

Customer Data

Order Data

Employee Data

Policy Data

Transaction Data

Without Repository Pattern:

@Service
public class CustomerService {

    public Customer getCustomer(Long id) {

        EntityManager em = ...

        return em.find(
                Customer.class,
                id);
    }
}

Problems:

Database Logic Inside Service

Code Duplication

Difficult Testing

Tight Coupling

Repository Pattern solves this problem.

What is Repository Pattern?

Repository Pattern acts as a collection-like interface between the domain layer and database layer.

Instead of:

Service → Database

Use:

Service

↓

Repository

↓

Database

Purpose of Repository Pattern

Primary Goal:

Abstract Database Access

From Business Logic

Real World Analogy

Think about a library.

Users don't directly access:

Book Storage Room

Instead:

User

↓

Librarian

↓

Storage

Librarian acts as Repository.

Problem Without Repository

flowchart LR
    A[Service]
    B[SQL Queries]
    C[Database]

    A --> B
    B --> C

Business layer knows database details.

Solution With Repository

flowchart LR
    A[Service]
    B[Repository]
    C[Database]

    A --> B
    B --> C

Database access centralized.

Repository Architecture

flowchart LR
    A[Controller]
    B[Service]
    C[Repository]
    D[Database]

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

Responsibilities

Repository handles:

CRUD Operations

Database Queries

Persistence Logic

Data Retrieval

CRUD Operations

Create

Read

Update

Delete

UML Diagram

classDiagram

class CustomerRepository {
    +save()
    +findById()
    +findAll()
    +delete()
}

class CustomerService

CustomerService --> CustomerRepository

Customer Entity

@Entity
public class Customer {

    @Id
    private Long id;

    private String name;

    private String email;

}

Repository Interface

public interface CustomerRepository {

    Customer findById(Long id);

    List<Customer> findAll();

    Customer save(Customer customer);

    void delete(Long id);
}

Repository Implementation

@Repository
public class CustomerRepositoryImpl
        implements CustomerRepository {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public Customer findById(Long id) {

        return entityManager.find(
                Customer.class,
                id);
    }

    @Override
    public Customer save(
            Customer customer) {

        entityManager.persist(
                customer);

        return customer;
    }
}

Service Layer

@Service
public class CustomerService {

    private final CustomerRepository repository;

    public CustomerService(
            CustomerRepository repository) {

        this.repository = repository;
    }

    public Customer getCustomer(
            Long id) {

        return repository.findById(id);
    }
}

Request Flow

flowchart LR
    A[Controller]
    B[Service]
    C[Repository]
    D[Database]

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

Spring Data JPA

Spring automatically generates repository implementations.

Developer writes:

public interface CustomerRepository
        extends JpaRepository<
                Customer,
                Long> {

}

Spring generates:

save()

findById()

findAll()

delete()

Automatically.

Spring Data JPA Flow

flowchart LR
    A[Repository Interface]
    B[Spring Data JPA]
    C[Generated Implementation]

    A --> B
    B --> C

CRUD Example

Save

repository.save(customer);

Find By Id

repository.findById(id);

Find All

repository.findAll();

Delete

repository.deleteById(id);

Derived Query Methods

Spring Data JPA supports:

findByEmail(String email);

findByName(String name);

findByStatus(String status);

Spring generates SQL automatically.

Query Generation Flow

flowchart LR
    A[findByEmail]
    B[Spring Data]
    C[Generated SQL]
    D[Database]

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

Custom Query Example

@Query("""
SELECT c
FROM Customer c
WHERE c.email = :email
""")
Customer findCustomer(
        String email);

Banking Example

Entities:

Account

Transaction

Customer

Loan

Repositories:

AccountRepository

LoanRepository

TransactionRepository

Banking Architecture

flowchart LR
    A[Controller]
    B[Service]
    C[AccountRepository]
    D[Database]

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

Fund Transfer Flow

flowchart LR
    A[Transfer Request]
    B[Transfer Service]
    C[Account Repository]
    D[Database]

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

Insurance Example

Entities:

Policy

Claim

Customer

Premium

Repositories:

PolicyRepository

ClaimRepository

Insurance Workflow

flowchart LR
    A[Claim Request]
    B[Claim Service]
    C[Claim Repository]
    D[Database]

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

Repository vs DAO

Feature	Repository	DAO
Focus	Domain Objects	Database Tables
Abstraction	High	Medium
DDD Friendly	Yes	No
Spring Data JPA	Yes	Limited

DAO Example

CustomerDao

Focuses on:

Database Access

Repository Example

CustomerRepository

Focuses on:

Domain Objects

Repository vs Service

Service	Repository
Business Logic	Data Access
Validation	CRUD
Workflow	Queries

Testing Example

Mock Repository:

CustomerRepository repository =
        Mockito.mock(
                CustomerRepository.class);

Service testing becomes easy.

Unit Testing Flow

flowchart LR
    A[Test]
    B[Mock Repository]
    C[Service]

    A --> B
    B --> C

Enterprise Examples

Banking

Account Management

Loan Processing

Transaction History

Insurance

Policy Management

Claim Processing

Retail

Order Management

Inventory Tracking

Healthcare

Patient Records

Appointment Systems

Common Spring Repositories

JpaRepository

CrudRepository

PagingAndSortingRepository

JpaRepository Benefits

Provides:

CRUD

Pagination

Sorting

Batch Operations

Enterprise Architecture

flowchart LR
    A[Client]
    B[Controller]
    C[Service]
    D[Repository]
    E[Database]

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

Benefits

✅ Database Abstraction

✅ Cleaner Service Layer

✅ Better Testability

✅ Reusable Queries

✅ Supports DDD

✅ Easy Spring Integration

Limitations

❌ Extra Layer

❌ More Classes

❌ Can Be Overkill For Small Apps

When To Use

Use Repository Pattern when:

Enterprise Applications
Spring Boot Applications
Database Access Layer
Domain Driven Design

When Not To Use

Avoid when:

Very Small Utilities
Simple Scripts
One-Time Applications

Interview Questions

What is Repository Pattern?

A pattern that abstracts data access from business logic.

Why Use Repository?

To separate persistence logic from service logic.

Repository vs DAO?

Repository works with domain models.

DAO works with database operations.

Spring Repository Annotation?

@Repository

Spring Data JPA Repository?

JpaRepository

Main Benefit?

Loose coupling between business logic and persistence layer.

Key Takeaways

Repository Pattern abstracts database operations.
Separates persistence logic from business logic.
Commonly used with Spring Data JPA.
Supports CRUD, Pagination, Sorting, and Custom Queries.
Makes applications more testable and maintainable.
Widely used in Banking, Insurance, Retail, and Healthcare systems.
Foundation of modern Spring Boot enterprise applications.