JpaRepository interface in Spring Boot - Mini Project: Build & Apply

Using JpaRepository Interface in Spring Boot

📖 Scenario: You are building a simple Spring Boot application to manage a list of books in a library. You want to store book data in a database and use Spring Data JPA to handle database operations easily.

🎯 Goal: Create a Spring Boot repository interface using JpaRepository to manage Book entities. You will set up the entity, configure the repository interface, and use it to perform basic database operations.

📋 What You'll Learn

Create a Book entity class with id, title, and author fields

Create a repository interface called BookRepository that extends JpaRepository

Use the repository interface to find all books

Add a method to find books by author name

💡 Why This Matters

🌍 Real World

Spring Data JPA repositories simplify database access in real-world Java applications by providing ready-made methods and easy ways to add custom queries.

💼 Career

Knowing how to use JpaRepository is essential for Java backend developers working with Spring Boot to build efficient and maintainable data access layers.

1

Create the Book entity class

Create a Java class called Book annotated with @Entity. Add private fields Long id, String title, and String author. Annotate id with @Id and @GeneratedValue. Include public getters and setters for all fields.

Spring Boot

@Entity
public class Book {
    // Your code here
}

Hint

Use @Entity to mark the class as a database entity. Use @Id and @GeneratedValue on the id field. Add getters and setters for all fields.

2

Create the BookRepository interface

Create a public interface called BookRepository that extends JpaRepository<Book, Long>. This interface will allow Spring Data JPA to provide basic database operations for Book entities.

Spring Boot

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.GeneratedValue;

@Entity
public class Book {
    @Id
    @GeneratedValue
    private Long id;
    private String title;
    private String author;

    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 getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

// Your code here

Hint

Extend JpaRepository with the entity Book and its ID type Long.

3

Add method to find all books

Inside the BookRepository interface, add a method declaration List<Book> findAll() to retrieve all books from the database.

Spring Boot

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.GeneratedValue;

@Entity
public class Book {
    @Id
    @GeneratedValue
    private Long id;
    private String title;
    private String author;

    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 getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

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

public interface BookRepository extends JpaRepository {
    // Add method to find all books
    // Your code here
}

Hint

Declare the method List<Book> findAll() inside the interface. JpaRepository already provides this method, but declaring it explicitly helps understanding.

4

Add method to find books by author

Add a method declaration List<Book> findByAuthor(String author) inside the BookRepository interface. This method will allow finding all books by a specific author.

Spring Boot

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.GeneratedValue;

@Entity
public class Book {
    @Id
    @GeneratedValue
    private Long id;
    private String title;
    private String author;

    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 getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

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

public interface BookRepository extends JpaRepository {
    List findAll();
    // Add method to find books by author
    // Your code here
}

Hint

Use Spring Data JPA's method naming convention to create findByAuthor method that takes a String author parameter.

Practice

1. What is the primary purpose of the JpaRepository interface in Spring Boot?

easy

A. To provide built-in methods for database operations on entities

B. To define the structure of REST API endpoints

C. To manage application security and authentication

D. To handle frontend UI rendering

Solution

1. Step 1: Understand JpaRepository role

   JpaRepository is designed to simplify database access by providing ready-made methods like save, findAll, and delete for entity classes.

2. Step 2: Compare with other options

   Options A, C, and D relate to REST API endpoints, security, and UI rendering, which are not responsibilities of JpaRepository.

3. Final Answer:

   To provide built-in methods for database operations on entities -> Option A

4. Quick Check:

   JpaRepository = database helper [OK]

Hint: JpaRepository = database methods for entities [OK]

Common Mistakes:

• Confusing JpaRepository with REST controllers
• Thinking it manages security
• Assuming it handles UI rendering

2. Which of the following is the correct way to declare a repository interface for an entity User with primary key type Long using JpaRepository?

easy

A. public interface UserRepository extends Repository<User> {}

B. public class UserRepository implements JpaRepository {}

C. public interface UserRepository extends JpaRepository {}

D. public interface UserRepository extends JpaRepository {}

Solution

1. Step 1: Check JpaRepository declaration syntax

   JpaRepository is an interface that should be extended, not implemented. The generic parameters are , so is correct.

2. Step 2: Validate each option

   public interface UserRepository extends JpaRepository {} correctly extends JpaRepository with . public class UserRepository implements JpaRepository {} incorrectly uses implements and class. public interface UserRepository extends JpaRepository {} swaps generic types. public interface UserRepository extends Repository<User> {} uses Repository, not JpaRepository.

3. Final Answer:

   public interface UserRepository extends JpaRepository {} -> Option D

4. Quick Check:

   Extend JpaRepository [OK]

Hint: Extend JpaRepository interface [OK]

Common Mistakes:

• Using implements instead of extends
• Swapping generic type order
• Using Repository instead of JpaRepository

3. Given the following repository method declaration:

List<User> findByLastName(String lastName);

What will this method do when called with findByLastName("Smith")?

medium

A. Return all User entities with lastName exactly 'Smith'

B. Return all User entities with lastName containing 'Smith'

C. Return a single User entity with lastName 'Smith'

D. Throw a runtime error because the method is invalid

Solution

1. Step 1: Understand method naming convention

   JpaRepository supports query derivation by method names. 'findByLastName' means find all entities where lastName equals the given parameter.

2. Step 2: Analyze return type and behavior

   The return type is List<User>, so it returns all matching users with lastName exactly 'Smith'. It does not do partial matching or throw errors.

3. Final Answer:

   Return all User entities with lastName exactly 'Smith' -> Option A

4. Quick Check:

   findByProperty = exact match [OK]

Hint: findByX = exact match, returns list if List type [OK]

Common Mistakes:

• Assuming it does partial matching
• Expecting a single result instead of list
• Thinking method is invalid without @Query

4. Consider this repository interface:

public interface ProductRepository extends JpaRepository {
    List<Product> findByPriceGreaterThan(Double price);
}

Which of the following is a likely cause of a runtime error when calling findByPriceGreaterThan(null)?

medium

A. JpaRepository does not support comparison keywords like GreaterThan

B. Method name is invalid and causes compile error

C. Passing null causes a NullPointerException in the query generation

D. The return type List<Product> is incorrect

Solution

1. Step 1: Check method name and support

   JpaRepository supports keywords like GreaterThan for query derivation, so method name is valid and compiles fine.

2. Step 2: Analyze passing null parameter

   Passing null to a comparison query causes a NullPointerException at runtime because the query cannot compare with null.

3. Final Answer:

   Passing null causes a NullPointerException in the query generation -> Option C

4. Quick Check:

   Null param in comparison query = runtime error [OK]

Hint: Never pass null to comparison query methods [OK]

Common Mistakes:

• Thinking method name is invalid
• Assuming JpaRepository lacks GreaterThan support
• Believing return type causes error

5. You want to add a custom method to your OrderRepository that finds all orders placed between two dates. Which of the following method signatures correctly uses JpaRepository naming conventions to achieve this?

hard

A. List<Order> findOrdersBetweenDates(LocalDate start, LocalDate end);

B. List<Order> findByOrderDateBetween(LocalDate start, LocalDate end);

C. List<Order> getOrdersByDateRange(LocalDate start, LocalDate end);

D. List<Order> findByOrderDateRange(LocalDate start, LocalDate end);

Solution

1. Step 1: Recall JpaRepository method naming rules

   JpaRepository supports keywords like Between to filter values between two parameters. The property name must match entity field, here 'OrderDate'.

2. Step 2: Evaluate each method signature

   List<Order> findByOrderDateBetween(LocalDate start, LocalDate end); uses 'findByOrderDateBetween' which is correct. Options B, C, and D use unsupported or incorrect keywords and will not work.

3. Final Answer:

   List<Order> findByOrderDateBetween(LocalDate start, LocalDate end); -> Option B

4. Quick Check:

   Use Between keyword for range queries [OK]

Hint: Use 'Between' keyword for range queries in method name [OK]

Common Mistakes:

• Using unsupported keywords like 'Range' or 'BetweenDates'
• Not matching property name exactly
• Trying to create custom method without @Query but wrong name