Understanding Spring Data JPA Architecture

Course: Advanced Java Training

Topic: Understanding Spring Data JPA Architecture

Course Link: Advanced Java Training Course

Demo Link: Register for a Course Demo

Website: JustAcademy

1. Introduction to Spring Data JPA

Spring Data JPA is a module of the Spring Data family that simplifies database access in Java applications. It provides repository abstractions that reduce repetitive data-access code and integrate with the Java Persistence API (JPA).

In a typical Spring Boot application, developers define entity classes to represent persistent data and repository interfaces to perform database operations. Spring Data JPA provides implementations for common repository operations, allowing developers to use methods such as save(), findById(), findAll(), and deleteById() without manually writing the same CRUD logic repeatedly.

JPA is a specification that defines how Java objects are mapped to relational database tables. Hibernate is a commonly used JPA implementation that handles object-relational mapping and communicates with the database through JDBC.

Why Is Spring Data JPA Important?

• Reduces repetitive database-access code.
• Provides ready-to-use CRUD operations.
• Supports query methods derived from repository method names.
• Allows custom queries using JPQL and native SQL.
• Integrates with Spring Boot dependency injection and configuration.
• Supports pagination, sorting, auditing, and transaction management.
• Separates business logic from persistence logic.
• Supports compatible relational databases through JPA providers and JDBC drivers.

2. Learning Objectives

After completing this topic, learners should be able to:

• Explain Spring Data JPA and its relationship with JPA and Hibernate.
• Understand the layers of a Spring Data JPA application.
• Identify the responsibilities of entities, repositories, services, and controllers.
• Understand the roles of EntityManager and EntityManagerFactory.
• Explain how Spring Data JPA creates repository implementations.
• Perform CRUD operations using JpaRepository.
• Understand derived query methods and custom queries.
• Explain transactions and the persistence context.
• Configure Spring Data JPA in a Spring Boot application.
• Identify common architecture problems and apply best practices.

3. Core Components of Spring Data JPA Architecture

3.1 Spring Data JPA

Spring Data JPA provides repository interfaces and infrastructure for implementing data-access operations. Developers declare repository interfaces, and Spring Data creates implementations at runtime for supported methods.

import org.springframework.data.jpa.repository.JpaRepository;

public interface EmployeeRepository
        extends JpaRepository<Employee, Long> {
}

This interface provides common database operations for the Employee entity without requiring a manually written implementation class.

3.2 Java Persistence API (JPA)

JPA defines standard interfaces and annotations for mapping Java objects to relational database tables. It describes how entities are persisted, retrieved, updated, and deleted.

3.3 Hibernate

Hibernate is an object-relational mapping (ORM) framework that commonly implements JPA in Spring Boot applications. It translates persistence operations into SQL and coordinates entity state with the relational database.

For example, when an application saves a new Employee entity, Spring Data JPA delegates the persistence operation through JPA. Hibernate can then generate the SQL needed to insert the corresponding database row.

3.4 JDBC

Java Database Connectivity (JDBC) is the Java API used to communicate with relational databases. Hibernate commonly uses JDBC and a compatible database driver to execute SQL statements and retrieve results.

3.5 Relational Database

The database stores persistent application data in tables, rows, and columns. Common databases used with Spring Data JPA include MySQL, PostgreSQL, Oracle Database, and compatible in-memory databases.

4. Spring Data JPA Architecture Diagram

Spring Data JPA is commonly used in a layered application architecture. Each layer has a specific responsibility, making the application easier to maintain, test, and extend.

Client / Browser / API Consumer
              |
              v
       Controller Layer
              |
              v
        Service Layer
              |
              v
      Repository Interface
              |
              v
Spring Data JPA Repository Proxy
              |
              v
        JPA EntityManager
              |
              v
     Hibernate JPA Provider
              |
              v
        JDBC and Driver
              |
              v
       Relational Database

Responsibilities of Each Layer

5. Understanding the Controller Layer

The controller layer is commonly the entry point for HTTP requests in a Spring Boot REST application. It uses annotations such as @RestController, @RequestMapping, @GetMapping, and @PostMapping to map URLs and HTTP methods to Java methods.

The controller should primarily handle HTTP-related responsibilities, such as accepting input, invoking a service, and returning an appropriate response. Business rules and persistence logic should normally be placed in separate layers.

Example Controller

import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/api/employees")
public class EmployeeController {

    private final EmployeeService employeeService;

    public EmployeeController(EmployeeService employeeService) {
        this.employeeService = employeeService;
    }

    @GetMapping
    public List<Employee> getAllEmployees() {
        return employeeService.getAllEmployees();
    }
}

In this example, the controller delegates the request to EmployeeService instead of directly accessing the database.

6. Understanding the Service Layer

The service layer contains business logic and coordinates operations involving repositories or other services. It provides a clear separation between the web layer and the persistence layer.

For example, an employee service might validate employee information, check whether an email is already registered, and then save the employee through a repository.

Example Service Class

import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class EmployeeService {

    private final EmployeeRepository employeeRepository;

    public EmployeeService(EmployeeRepository employeeRepository) {
        this.employeeRepository = employeeRepository;
    }

    public List<Employee> getAllEmployees() {
        return employeeRepository.findAll();
    }

    public Employee saveEmployee(Employee employee) {
        return employeeRepository.save(employee);
    }
}

Benefits of the Service Layer

• Centralizes business rules.
• Reduces duplication across controllers.
• Makes business logic easier to unit test.
• Coordinates multiple repository operations.
• Provides a suitable place for transaction boundaries when required.

7. Understanding the Repository Layer

The repository layer provides an abstraction over data-access operations. In Spring Data JPA, developers typically define an interface that extends a repository type such as CrudRepository or JpaRepository.

Spring Data detects the interface and creates a runtime implementation that provides inherited methods and supported query methods.

Example Repository Interface

import org.springframework.data.jpa.repository.JpaRepository;

public interface EmployeeRepository
        extends JpaRepository<Employee, Long> {
}

The type parameters specify the entity class and the entity's identifier type. In this example, Employee is the entity and Long is its primary key type.

Common Repository Methods

Some repository methods can trigger database queries immediately, while others work through the persistence context and may defer SQL execution until flushing or transaction completion.

8. Understanding Entity Classes

An entity is a Java class mapped to a database table. Each entity instance represents a persistent object whose state can be stored in or retrieved from a database.

Example Employee Entity

import jakarta.persistence.*;

@Entity
@Table(name = "employees")
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 100)
    private String name;

    @Column(nullable = false, unique = true, length = 150)
    private String email;

    public Employee() {
    }

    public Employee(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Explanation of Annotations

• @Entity tells JPA that the class represents a persistent entity.
• @Table(name = "employees") specifies the database table name.
• @Id marks the primary key.
• @GeneratedValue configures identifier generation.
• @Column configures mapping properties such as length, uniqueness, and nullability.
• The no-argument constructor supports JPA entity instantiation requirements.

Entity classes should be designed according to the selected JPA version and provider. Database constraints should also be managed appropriately through migrations or schema-management tools.

9. Understanding EntityManager

EntityManager is a core JPA interface that manages entity instances within a persistence context. It provides operations to persist, find, merge, remove, and flush entities.

Common EntityManager Methods

Spring Data JPA uses EntityManager internally for many repository operations. Developers can also use EntityManager directly when custom persistence behavior is required.

EntityManager Example

import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import org.springframework.stereotype.Repository;

@Repository
public class EmployeeCustomRepository {

    @PersistenceContext
    private EntityManager entityManager;

    public Employee findEmployee(Long id) {
        return entityManager.find(Employee.class, id);
    }
}

For ordinary CRUD operations, a Spring Data repository is usually simpler. Direct EntityManager usage is useful for specialized queries, bulk operations, or persistence behavior that is not conveniently expressed through a repository method.

10. Understanding EntityManagerFactory

EntityManagerFactory creates EntityManager instances. It is associated with persistence-unit configuration, entity mappings, and the JPA provider.

In a typical Spring Boot application, the framework configures persistence infrastructure automatically when the required dependencies and datasource properties are present.

EntityManagerFactory vs. EntityManager

11. Understanding the Persistence Context

The persistence context is the set of entity instances managed by a particular EntityManager. It tracks changes to managed entities and helps maintain entity identity within that context.

When an entity is loaded and remains managed, changing its fields can result in a database update during flushing or transaction commit. This behavior is commonly called dirty checking.

Entity Lifecycle States

Example of Dirty Checking

import org.springframework.transaction.annotation.Transactional;

@Transactional
public void updateEmployeeName(Long id, String newName) {
    Employee employee = employeeRepository.findById(id)
        .orElseThrow(() ->
            new IllegalArgumentException("Employee not found"));

    employee.setName(newName);
}

In this example, the employee is loaded inside a transaction. If it remains managed and the transaction completes successfully, JPA can detect the changed name and synchronize it with the database. An explicit call to save() is generally not required for a managed entity in this scenario.

12. How Spring Data JPA Works Internally

Spring Data JPA reduces the need to manually implement common persistence operations. Its repository infrastructure discovers repository interfaces, creates proxies, and connects repository methods to the JPA infrastructure.

Repository Execution Flow

1. The application starts and Spring scans eligible components and repository interfaces.
2. Spring Data identifies repository interfaces and creates repository bean proxies.
3. The repository infrastructure prepares implementations for inherited operations and supported query methods.
4. A service calls a repository method, such as findById().
5. The repository implementation uses JPA facilities, commonly through EntityManager.
6. The JPA provider, such as Hibernate, determines the required persistence operations.
7. The provider communicates with the database through JDBC when database access is needed.
8. The result is mapped to Java entities and returned through the repository to the calling service.

This process hides much of the infrastructure code while allowing developers to focus on domain logic and required queries.

13. CRUD Operations with Spring Data JPA

CRUD stands for Create, Read, Update, and Delete. These are the fundamental operations required by most data-driven applications.

13.1 Create an Employee

Employee employee =
        new Employee("Neha Patel", "[email protected]");

Employee savedEmployee = employeeRepository.save(employee);

The repository's save() method delegates to JPA persistence behavior. Depending on entity-state detection and the persistence implementation, the operation may persist a new entity or merge an existing entity.

13.2 Read an Employee

Employee employee = employeeRepository.findById(1L)
        .orElseThrow(() ->
            new IllegalArgumentException("Employee not found"));

The return type of findById() is Optional<Employee>. This makes the possibility of a missing record explicit.

13.3 Update an Employee

import org.springframework.transaction.annotation.Transactional;

@Transactional
public Employee updateEmployeeEmail(Long id, String email) {
    Employee employee = employeeRepository.findById(id)
        .orElseThrow(() ->
            new IllegalArgumentException("Employee not found"));

    employee.setEmail(email);
    return employee;
}

Because the entity is managed inside the transaction, dirty checking can synchronize the changed email. An application can also use save() where appropriate, but should understand the distinction between managed and detached entities.

13.4 Delete an Employee

public void deleteEmployee(Long id) {
    employeeRepository.deleteById(id);
}

Deletion behavior depends on the repository operation and database state. Applications should define how missing IDs, related records, and integrity constraints are handled.

14. Query Methods and Derived Queries

Spring Data JPA can derive queries from repository method names. This reduces the need to write explicit query strings for common lookup operations.

Example Repository

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
import java.util.Optional;

public interface EmployeeRepository
        extends JpaRepository<Employee, Long> {

    Optional<Employee> findByEmail(String email);

    List<Employee> findByName(String name);

    List<Employee> findByNameContainingIgnoreCase(String keyword);

    boolean existsByEmail(String email);

    List<Employee> findByNameOrderByIdDesc(String name);
}

Common Query Method Keywords

15. Custom Queries Using @Query

When a query is too complex for a derived method name, developers can use the @Query annotation. By default, JPQL queries refer to entity names and Java properties rather than physical table and column names.

Example JPQL Query

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;

public interface EmployeeRepository
        extends JpaRepository<Employee, Long> {

    @Query("SELECT e FROM Employee e WHERE e.name = :name")
    List<Employee> findEmployeesByName(
            @Param("name") String name);
}

Native SQL Query

@Query(
    value = "SELECT * FROM employees WHERE email = :email",
    nativeQuery = true
)
Optional<Employee> findByEmailUsingSql(
        @Param("email") String email);

Native SQL uses the database's SQL syntax and physical schema. It can be useful for database-specific queries, but it may reduce portability between database systems.

16. Transaction Management in Spring Data JPA

A transaction groups database operations into a logical unit of work. Transactions help preserve data consistency and support atomic operations when multiple changes must succeed or fail together.

Spring applications commonly use the @Transactional annotation to declare transaction boundaries.

Example Transactional Service

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class EmployeeManagementService {

    private final EmployeeRepository employeeRepository;

    public EmployeeManagementService(
            EmployeeRepository employeeRepository) {
        this.employeeRepository = employeeRepository;
    }

    @Transactional
    public Employee createEmployee(Employee employee) {
        return employeeRepository.save(employee);
    }
}

Important Transaction Concepts

• Commit: Finalizes a successful transaction.
• Rollback: Reverses transactional database changes when rollback rules apply.
• Atomicity: Treats a group of changes as one logical operation.
• Consistency: Helps preserve database constraints and application invariants.
• Isolation: Controls how concurrent transactions interact.
• Propagation: Defines how transactional methods participate in existing transactions or create new ones.

By default, Spring's declarative transaction management generally rolls back on unchecked exceptions and errors, while checked exceptions do not trigger rollback unless configured. Transaction behavior should be reviewed for the application's requirements.

17. Pagination and Sorting

Retrieving every row from a large table can consume unnecessary memory and processing time. Spring Data JPA supports pagination and sorting through types such as Pageable, Page, and Sort.

Example Repository Method

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;

public interface EmployeeRepository
        extends JpaRepository<Employee, Long> {

    Page<Employee> findByNameContainingIgnoreCase(
            String name, Pageable pageable);
}

Example Service Usage

import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;

public Page<Employee> searchEmployees(String keyword) {
    PageRequest pageRequest = PageRequest.of(
        0,
        10,
        Sort.by("name").ascending()
    );

    return employeeRepository
            .findByNameContainingIgnoreCase(
                keyword, pageRequest);
}

Page numbering commonly starts at zero. A Page can provide content and metadata such as the total number of elements and pages. For large datasets or high-traffic APIs, choose pagination strategies based on query cost and the application's access patterns.

18. Database Configuration in Spring Boot

Spring Boot can configure much of the datasource and JPA infrastructure from application properties. The exact dependency versions should be compatible with the Spring Boot version selected for the project.

Example Maven Dependencies

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

Example application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/company_db
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Replace the database URL and environment variables with values appropriate for your environment. The database and schema must exist or be created according to the project's configuration.

Important: spring.jpa.hibernate.ddl-auto=update is convenient for learning and some development workflows. For production systems, controlled database migrations are generally safer. Do not hard-code real database credentials in source control.

19. Understanding Repository Proxy Generation

One of the main benefits of Spring Data JPA is that developers do not usually need to implement repository interfaces manually. Spring detects repository definitions and creates proxy-backed beans that implement the required behavior.

How It Works

1. A developer declares a repository interface that extends a supported Spring Data repository interface.
2. Spring Data scans for eligible repository definitions during application initialization.
3. The framework builds repository metadata from the interface and its generic types.
4. The infrastructure creates a repository proxy backed by the relevant repository implementation and query mechanisms.
5. Spring injects the repository bean into services or other application components.
6. When a method is called, the proxy dispatches the operation to the appropriate implementation or query execution strategy.

Repository method names, annotations, and supported query types help Spring Data determine how to execute the requested operation. If a query method cannot be resolved or validated, the application may report a configuration error during startup or repository initialization.

20. Exception Handling in Spring Data JPA

Database operations can fail for several reasons, including duplicate unique values, missing related records, invalid queries, connection failures, and constraint violations. Spring translates many persistence exceptions into its data-access exception hierarchy.

Example: Handling a Missing Employee

public Employee getEmployeeById(Long id) {
    return employeeRepository.findById(id)
        .orElseThrow(() ->
            new IllegalArgumentException(
                "Employee not found with ID: " + id));
}

In a REST application, a centralized exception handler using @RestControllerAdvice can translate application exceptions into consistent HTTP responses. Avoid exposing database internals or stack traces to API consumers.

21. Spring Data JPA vs. Traditional JDBC

Neither approach is universally better. Spring Data JPA is useful for many domain-oriented applications, while JDBC can be appropriate when direct SQL control, specialized data operations, or particular performance characteristics are important.

22. Common Architecture Mistakes

• Putting all logic in controllers: Move business rules into the service layer when appropriate.
• Returning persistence entities directly in every API: Consider DTOs to control exposed fields and decouple API contracts from database mappings.
• Loading every record: Use pagination or targeted queries for large datasets.
• Ignoring transaction boundaries: Define transactions around business operations that need coordinated persistence changes.
• Overusing eager fetching: Fetch only the relationships needed for the use case.
• Ignoring N+1 queries: Inspect SQL and use suitable fetch joins, entity graphs, projections, or other query strategies.
• Assuming save always means INSERT: Understand entity-state detection and persist/merge behavior.
• Using entity classes as request models without considering validation: Use suitable request DTOs and validation rules.
• Exposing credentials in configuration files: Use environment-based configuration or secure secret management.
• Relying on automatic schema updates in production: Use controlled schema migrations and review database changes.

23. Best Practices for Spring Data JPA Architecture

• Keep controllers focused on HTTP concerns.
• Put business logic in service classes.
• Use repository interfaces for common persistence operations.
• Choose clear entity names and explicit mappings when helpful.
• Use DTOs to define API request and response contracts.
• Use @Transactional where a business operation needs a transaction boundary.
• Use query methods for simple queries and @Query for more complex queries.
• Use pagination and sorting for large result sets.
• Inspect generated SQL and query plans when performance matters.
• Design entity relationships and fetch strategies carefully.
• Use database constraints to protect data integrity.
• Keep database credentials outside source control.
• Test repository behavior with appropriate integration tests.
• Use schema migration tools for controlled database changes.
• Keep Spring Boot, Spring Data JPA, the JPA provider, and database driver versions compatible.

24. Practical Exercise: Employee Management Application

Create a Spring Boot application that manages employee records using Spring Data JPA and a relational database.

Project Requirements

1. Create a Spring Boot project with Spring Web, Spring Data JPA, and a database driver.
2. Configure the database connection using application properties.
3. Create an Employee entity with an ID, name, and email.
4. Create an EmployeeRepository extending JpaRepository.
5. Create an EmployeeService for business operations.
6. Create an EmployeeController that exposes REST endpoints.
7. Implement create, read, update, and delete operations.
8. Add a repository query method to find employees by email.
9. Add validation for required fields and valid email addresses.
10. Handle missing employee IDs with an appropriate error response.
11. Test endpoints with Postman.
12. Inspect SQL logs and observe how repository operations interact with the database.

Suggested Endpoint Design

25. Interview Questions and Answers

Q1. What is Spring Data JPA?

Answer: Spring Data JPA is a Spring Data module that simplifies persistence with JPA by providing repository abstractions, query derivation, and integration with Spring infrastructure.

Q2. What is the difference between JPA and Hibernate?

Answer: JPA is a specification defining persistence APIs and behavior. Hibernate is a framework that implements JPA and provides object-relational mapping functionality.

Q3. What is the role of JpaRepository?

Answer: JpaRepository provides common CRUD and JPA-oriented repository operations, including methods for retrieving, saving, deleting, sorting, and paging data.

Q4. Does Spring Data JPA automatically implement repository interfaces?

Answer: Yes. Spring Data detects supported repository interfaces and creates proxy-backed implementations at runtime.

Q5. What is an entity in JPA?

Answer: An entity is a Java class mapped to a persistent data structure, typically a relational database table.

Q6. What is EntityManager?

Answer: EntityManager is a JPA interface used to manage entity persistence operations and the persistence context.

Q7. What is a persistence context?

Answer: It is the context in which entity instances are managed and their state changes can be tracked.

Q8. What is dirty checking?

Answer: Dirty checking allows JPA providers to detect changes to managed entities and synchronize those changes with the database during flushing or transaction completion.

Q9. What is the purpose of @Transactional?

Answer: It declares transactional behavior so database operations can be executed within a defined transaction boundary.

Q10. What is the difference between save() and saveAndFlush()?

Answer: save() saves an entity through repository persistence behavior but does not necessarily flush changes immediately. saveAndFlush() saves and requests an immediate flush of pending changes to the database.

Q11. What is a derived query method?

Answer: It is a repository method whose name describes query conditions, such as findByEmail() or findByNameContainingIgnoreCase().

Q12. What is the purpose of @Query?

Answer: It defines a custom query, commonly using JPQL or native SQL, when a derived query method is not suitable.

Q13. What is the difference between JPQL and SQL?

Answer: JPQL queries entities and their properties, whereas SQL typically queries physical database tables and columns.

Q14. Why is pagination important?

Answer: Pagination limits the number of records returned in a single request, helping control memory use and response size for large datasets.

Q15. What is the N+1 query problem?

Answer: It occurs when an initial query retrieves a group of records and additional queries are executed repeatedly to load related data. Appropriate fetch strategies, projections, and query design can help reduce it.

Q16. What is the difference between EntityManagerFactory and EntityManager?

Answer: EntityManagerFactory creates EntityManager instances, while EntityManager performs persistence operations and manages entities within a persistence context.

Q17. Why use a service layer?

Answer: The service layer centralizes business logic, coordinates operations, and separates application rules from web and persistence concerns.

Q18. Can Spring Data JPA use native SQL?

Answer: Yes. A repository method can use a native query when database-specific SQL or direct access to physical table structures is required.

Q19. What is the difference between a managed and detached entity?

Answer: A managed entity is tracked by a persistence context. A detached entity is no longer associated with that context, so its changes are not automatically tracked there.

Q20. How can Spring Data JPA performance be improved?

Answer: Use efficient queries, pagination, suitable indexes, projections, appropriate fetch strategies, and transaction boundaries. Inspect generated SQL and database query plans to identify bottlenecks.

26. Quick Revision Checklist

• Spring Data JPA simplifies data access through repository abstractions.
• JPA is a specification; Hibernate is a common JPA implementation.
• Entities represent persistent domain objects.
• Repositories declare persistence methods and are implemented through Spring Data infrastructure.
• EntityManager manages persistence operations and the persistence context.
• Hibernate commonly translates JPA operations into SQL.
• Services coordinate business logic and repositories.
• Transactions help keep related database changes consistent.
• Query methods and @Query support data retrieval.
• Pagination helps manage large query results.
• Fetch strategies and query design affect performance.
• Validation, exception handling, and database constraints help protect data integrity.

27. Conclusion

Understanding Spring Data JPA architecture helps Java developers build maintainable, database-driven applications. The architecture combines Spring's dependency injection and repository infrastructure with JPA's persistence abstractions, a provider such as Hibernate, JDBC, and a relational database.

By separating controllers, services, repositories, and entities, developers can organize application responsibilities and reduce repetitive persistence code. A strong understanding of repository behavior, EntityManager, transactions, query methods, pagination, and fetch strategies is essential for creating reliable and efficient Spring Boot applications.

To continue learning backend development, explore the Advanced Java Training Course at JustAcademy, visit the JustAcademy homepage, or register for a course demo.

28. Further Reading

• Spring Data JPA Official Project Page
• Spring Data JPA Reference Documentation
• Jakarta Persistence Specification