Skip to main content

Spring Data JPA

Introduction​

Spring Data JPA is a powerful module within the Spring Data family that significantly simplifies the implementation of JPA (Java Persistence API) based data access layers. It eliminates much of the boilerplate code typically associated with JDBC and traditional ORM (Object-Relational Mapping) approaches, allowing developers to focus on business logic rather than repetitive data access code.

As a beginner, you might wonder why Spring Data JPA is so valuable. Imagine writing dozens of lines of code just to perform simple database operations like finding, saving, or deleting records. Spring Data JPA reduces these operations to just a few lines, or even single method calls, making your code cleaner and more maintainable.

What is JPA?​

Before diving into Spring Data JPA, let's understand what JPA is:

Java Persistence API (JPA) is a specification that defines how to persist data between Java objects and relational databases. It acts as a bridge between object-oriented domain models and relational database systems. Hibernate is the most popular implementation of JPA.

Spring Data JPA builds on top of JPA, adding an extra layer of abstraction that further simplifies database interactions.

Getting Started with Spring Data JPA​

Setting Up Your Project​

To start using Spring Data JPA in your Spring Boot application, you need to add the appropriate dependencies.

For Maven:

xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

For Gradle:

groovy
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
runtimeOnly 'com.h2database:h2'

In this example, we're using H2 as an in-memory database for simplicity, but you can use any database like MySQL, PostgreSQL, etc.

Configuring the Database Connection​

For Spring Boot applications, you can configure the database connection in the application.properties or application.yml file:

properties
# H2 Database Configuration
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

# Enable H2 console
spring.h2.console.enabled=true

# JPA/Hibernate properties
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

Creating Your First Entity​

An entity in JPA represents a table in your database. Let's create a simple Book entity:

java
package com.example.library.entity;

import javax.persistence.*;

@Entity
@Table(name = "books")
public class Book {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String title;
    
    @Column(length = 500)
    private String description;
    
    @Column(name = "author_name")
    private String author;
    
    private int pages;
    
    // Constructors
    public Book() {
    }
    
    public Book(String title, String description, String author, int pages) {
        this.title = title;
        this.description = description;
        this.author = author;
        this.pages = pages;
    }
    
    // Getters and setters
    public Long getId() {
        return id;
    }
    
    public void setId(Long id) {
        this.id = id;
    }
    
    public String getTitle() {
        return title;
    }
    
    public void setTitle(String title) {
        this.title = title;
    }
    
    public String getDescription() {
        return description;
    }
    
    public void setDescription(String description) {
        this.description = description;
    }
    
    public String getAuthor() {
        return author;
    }
    
    public void setAuthor(String author) {
        this.author = author;
    }
    
    public int getPages() {
        return pages;
    }
    
    public void setPages(int pages) {
        this.pages = pages;
    }
    
    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", author='" + author + '\'' +
                ", pages=" + pages +
                '}';
    }
}

Let's break down the annotations used:

  • @Entity: Marks the class as a JPA entity
  • @Table: Specifies the name of the database table
  • @Id: Marks the field as the primary key
  • @GeneratedValue: Defines the primary key generation strategy
  • @Column: Customizes the mapping between the entity attribute and database column

Creating a Repository​

Spring Data JPA simplifies database operations by providing a repository abstraction. You only need to define an interface that extends one of Spring Data's repository interfaces, and Spring will automatically provide the implementation.

Let's create a repository for our Book entity:

java
package com.example.library.repository;

import com.example.library.entity.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
    
    // Custom finder methods
    List<Book> findByAuthor(String author);
    
    List<Book> findByTitleContaining(String title);
    
    List<Book> findByPagesGreaterThan(int pages);
}

By extending JpaRepository<Book, Long>, we tell Spring Data JPA that this repository manages Book entities with Long as the type of the primary key. The interface automatically provides CRUD operations and methods for pagination and sorting.

We've also defined some custom finder methods. Spring Data JPA will automatically implement these methods based on their names following a specific naming convention.

Using the Repository​

Now let's create a service class to use our repository:

java
package com.example.library.service;

import com.example.library.entity.Book;
import com.example.library.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class BookService {
    
    private final BookRepository bookRepository;
    
    @Autowired
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }
    
    public Book saveBook(Book book) {
        return bookRepository.save(book);
    }
    
    public List<Book> getAllBooks() {
        return bookRepository.findAll();
    }
    
    public Optional<Book> getBookById(Long id) {
        return bookRepository.findById(id);
    }
    
    public List<Book> getBooksByAuthor(String author) {
        return bookRepository.findByAuthor(author);
    }
    
    public List<Book> searchBooksByTitle(String titleKeyword) {
        return bookRepository.findByTitleContaining(titleKeyword);
    }
    
    public List<Book> getLargeBooks(int minPages) {
        return bookRepository.findByPagesGreaterThan(minPages);
    }
    
    public void deleteBook(Long id) {
        bookRepository.deleteById(id);
    }
}

Building a REST Controller​

Let's expose our service through a REST API:

java
package com.example.library.controller;

import com.example.library.entity.Book;
import com.example.library.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/books")
public class BookController {
    
    private final BookService bookService;
    
    @Autowired
    public BookController(BookService bookService) {
        this.bookService = bookService;
    }
    
    @PostMapping
    public ResponseEntity<Book> createBook(@RequestBody Book book) {
        Book savedBook = bookService.saveBook(book);
        return new ResponseEntity<>(savedBook, HttpStatus.CREATED);
    }
    
    @GetMapping
    public ResponseEntity<List<Book>> getAllBooks() {
        List<Book> books = bookService.getAllBooks();
        return new ResponseEntity<>(books, HttpStatus.OK);
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<Book> getBookById(@PathVariable Long id) {
        return bookService.getBookById(id)
                .map(book -> new ResponseEntity<>(book, HttpStatus.OK))
                .orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));
    }
    
    @GetMapping("/author/{author}")
    public ResponseEntity<List<Book>> getBooksByAuthor(@PathVariable String author) {
        List<Book> books = bookService.getBooksByAuthor(author);
        return new ResponseEntity<>(books, HttpStatus.OK);
    }
    
    @GetMapping("/search")
    public ResponseEntity<List<Book>> searchBooks(@RequestParam String title) {
        List<Book> books = bookService.searchBooksByTitle(title);
        return new ResponseEntity<>(books, HttpStatus.OK);
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteBook(@PathVariable Long id) {
        bookService.deleteBook(id);
        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    }
}

Advanced Spring Data JPA Features​

Query Methods​

Spring Data JPA provides a powerful feature that allows you to define query methods in your repository interface by just declaring their method signature. The query is automatically created from the method name.

Common naming patterns include:

  • findBy[Property]: Find entities with exact property match
  • findBy[Property]Containing: Find entities where the property contains a substring
  • findBy[Property]StartingWith: Find entities where property starts with a value
  • findBy[Property]EndingWith: Find entities where property ends with a value
  • findBy[Property]Between: Find entities where property is between two values
  • findBy[Property]LessThan: Find entities where property is less than a value
  • findBy[Property]GreaterThan: Find entities where property is greater than a value
  • findBy[Property]IsNull: Find entities where property is null
  • findBy[Property]IsNotNull: Find entities where property is not null
  • findBy[Property]OrderBy[OtherProperty]Desc: Find entities ordered by a property

Custom JPQL Queries​

For more complex queries, you can use JPQL (Java Persistence Query Language) with the @Query annotation:

java
@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
    
    @Query("SELECT b FROM Book b WHERE b.author = :author AND b.pages > :pageCount")
    List<Book> findLongBooksByAuthor(@Param("author") String author, @Param("pageCount") int pageCount);
    
    @Query("SELECT b FROM Book b WHERE b.title LIKE %:keyword% OR b.description LIKE %:keyword%")
    List<Book> searchBooksByKeyword(@Param("keyword") String keyword);
}

Native SQL Queries​

If you need to execute native SQL queries:

java
@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
    
    @Query(value = "SELECT * FROM books WHERE YEAR(publication_date) = :year", nativeQuery = true)
    List<Book> findBooksByPublicationYear(@Param("year") int year);
}

Pagination and Sorting​

Spring Data JPA makes pagination and sorting incredibly simple:

java
@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
    
    Page<Book> findByAuthor(String author, Pageable pageable);
    
    List<Book> findByTitleContaining(String title, Sort sort);
}

Usage in service:

java
public Page<Book> getBooksByAuthorPaginated(String author, int page, int size) {
    Pageable pageable = PageRequest.of(page, size, Sort.by("title").ascending());
    return bookRepository.findByAuthor(author, pageable);
}

public List<Book> searchBooksSortedByPages(String titleKeyword) {
    Sort sort = Sort.by("pages").descending();
    return bookRepository.findByTitleContaining(titleKeyword, sort);
}

Real-World Example: Library Management System​

Let's combine everything we've learned into a real-world example. We'll implement a simplified library management system.

First, let's add a new entity to represent a library user:

java
@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    @Column(unique = true, nullable = false)
    private String email;
    
    @OneToMany(mappedBy = "borrower", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Set<Book> borrowedBooks = new HashSet<>();
    
    // Constructors, getters, setters...
}

Now, let's update our Book entity to include borrowing information:

java
@Entity
@Table(name = "books")
public class Book {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String title;
    
    @Column(length = 500)
    private String description;
    
    @Column(name = "author_name")
    private String author;
    
    private int pages;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "borrower_id")
    private User borrower;
    
    @Column(name = "borrowed_date")
    private LocalDate borrowedDate;
    
    @Column(name = "due_date")
    private LocalDate dueDate;
    
    // Constructor, getters, setters...
}

Let's create repositories for both entities:

java
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}
java
public interface BookRepository extends JpaRepository<Book, Long> {
    List<Book> findByBorrowerIsNull();
    
    List<Book> findByBorrower(User borrower);
    
    @Query("SELECT b FROM Book b WHERE b.dueDate < CURRENT_DATE AND b.borrower IS NOT NULL")
    List<Book> findOverdueBooks();
}

Now, let's implement a service to handle book borrowing:

java
@Service
public class LibraryService {
    
    private final BookRepository bookRepository;
    private final UserRepository userRepository;
    
    @Autowired
    public LibraryService(BookRepository bookRepository, UserRepository userRepository) {
        this.bookRepository = bookRepository;
        this.userRepository = userRepository;
    }
    
    @Transactional
    public Book borrowBook(Long bookId, Long userId, int borrowDays) {
        Book book = bookRepository.findById(bookId)
                .orElseThrow(() -> new EntityNotFoundException("Book not found"));
        
        User user = userRepository.findById(userId)
                .orElseThrow(() -> new EntityNotFoundException("User not found"));
        
        if (book.getBorrower() != null) {
            throw new IllegalStateException("Book is already borrowed");
        }
        
        LocalDate borrowedDate = LocalDate.now();
        LocalDate dueDate = borrowedDate.plusDays(borrowDays);
        
        book.setBorrower(user);
        book.setBorrowedDate(borrowedDate);
        book.setDueDate(dueDate);
        
        return bookRepository.save(book);
    }
    
    @Transactional
    public Book returnBook(Long bookId) {
        Book book = bookRepository.findById(bookId)
                .orElseThrow(() -> new EntityNotFoundException("Book not found"));
        
        if (book.getBorrower() == null) {
            throw new IllegalStateException("Book is not borrowed");
        }
        
        book.setBorrower(null);
        book.setBorrowedDate(null);
        book.setDueDate(null);
        
        return bookRepository.save(book);
    }
    
    public List<Book> getAvailableBooks() {
        return bookRepository.findByBorrowerIsNull();
    }
    
    public List<Book> getUserBorrowedBooks(Long userId) {
        User user = userRepository.findById(userId)
                .orElseThrow(() -> new EntityNotFoundException("User not found"));
        return bookRepository.findByBorrower(user);
    }
    
    public List<Book> getOverdueBooks() {
        return bookRepository.findOverdueBooks();
    }
}

Finally, let's create a controller for this service:

java
@RestController
@RequestMapping("/api/library")
public class LibraryController {
    
    private final LibraryService libraryService;
    
    @Autowired
    public LibraryController(LibraryService libraryService) {
        this.libraryService = libraryService;
    }
    
    @GetMapping("/available")
    public ResponseEntity<List<Book>> getAvailableBooks() {
        List<Book> books = libraryService.getAvailableBooks();
        return new ResponseEntity<>(books, HttpStatus.OK);
    }
    
    @GetMapping("/borrowed/{userId}")
    public ResponseEntity<List<Book>> getUserBorrowedBooks(@PathVariable Long userId) {
        List<Book> books = libraryService.getUserBorrowedBooks(userId);
        return new ResponseEntity<>(books, HttpStatus.OK);
    }
    
    @GetMapping("/overdue")
    public ResponseEntity<List<Book>> getOverdueBooks() {
        List<Book> books = libraryService.getOverdueBooks();
        return new ResponseEntity<>(books, HttpStatus.OK);
    }
    
    @PostMapping("/borrow")
    public ResponseEntity<Book> borrowBook(
            @RequestParam Long bookId, 
            @RequestParam Long userId, 
            @RequestParam(defaultValue = "14") int days) {
        Book book = libraryService.borrowBook(bookId, userId, days);
        return new ResponseEntity<>(book, HttpStatus.OK);
    }
    
    @PostMapping("/return")
    public ResponseEntity<Book> returnBook(@RequestParam Long bookId) {
        Book book = libraryService.returnBook(bookId);
        return new ResponseEntity<>(book, HttpStatus.OK);
    }
}

This example demonstrates a simple library management system that allows users to borrow and return books, with functionality to track overdue books.

Summary​

Spring Data JPA is a powerful tool that simplifies database access in Spring applications. By providing repositories with auto-implemented methods, it eliminates boilerplate code and allows developers to focus on business logic. Key benefits include:

  1. Reduced Boilerplate: No need to write implementations for common CRUD operations
  2. Query Methods: Create custom queries using a simple method naming convention
  3. Pagination and Sorting: Built-in support for paginated results and sorted queries
  4. Transaction Management: Simplified transaction handling with annotations
  5. Integration with Other Spring Modules: Seamless integration with Spring MVC, Spring Boot, etc.

Throughout this guide, we've explored:

  • Setting up Spring Data JPA
  • Creating entities and repositories
  • Using basic and custom query methods
  • Implementing pagination and sorting
  • Writing custom JPQL and native SQL queries
  • Building a real-world application with relationships between entities

Additional Resources​

Exercises​

  1. Create a blog system with Post and Comment entities with a one-to-many relationship between them.
  2. Implement pagination and sorting for retrieving posts.
  3. Add a search functionality to find posts by title or content.
  4. Implement a tagging system for posts (many-to-many relationship).
  5. Create a REST API to manage posts, comments, and tags.

If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)