Spring Boot JpaRepository Example Tutorial

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

✅ Some premium posts are free to read — no account needed. Follow me on Medium to stay updated and support my writing.

🎓 Top 10 Udemy Courses (Huge Discount): Explore My Udemy Courses — Learn through real-time, project-based development.

▶️ Subscribe to My YouTube Channel (172K+ subscribers): Java Guides on YouTube

← Back to Spring Boot Tutorial

SpringBoot JpaRepository example tutorial shows how to use JpaRepository to manage data in a Spring Boot application.

As we know that Spring is a popular Java application framework. Spring Boot is an effort to create stand-alone, production-grade Spring based applications with minimal effort.

Spring Data

Spring Data JPA is not a JPA provider. It is a library/framework that adds an extra layer of abstraction on top of our JPA provider (like Hibernate).

Read more about Spring data at https://www.javaguides.net/2018/11/spring-data-jpa-tutorial-getting-started.html.

JpaRepository Interface

JpaRepository is JPA specific extension of Repository. It contains the full API of CrudRepository and PagingAndSortingRepository. So it contains API for basic CRUD operations and also API for pagination and sorting.

Spring Boot JpaRepository Example

The following Spring Boot application manages an Employee entity with JpaRepository. The data is saved in the H2 database. The application is a console program.

Create a Spring Boot Application

There are many ways to create a Spring Boot application. You can refer below articles to create a Spring Boot application.

>> Create Spring Boot Project With Spring Initializer
>> Create Spring Boot Project in Spring Tool Suite [STS]

Pom Dependencies - pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>net.guides.springboot2</groupId>
 <artifactId>springboot-jparepository-example</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>jar</packaging>

 <name>springboot2-jpa-crud-example</name>
 <description>Demo project for Spring Boot</description>

 <parent>
     <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>3.0.4</version>
         <relativePath /> <!-- lookup parent from repository -->
 </parent>

 <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
     <java.version>17</java.version>
 </properties>

 <dependencies>
     <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> 
 </dependencies>

 <build>
     <plugins>
         <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
     </plugins>
 </build>
</project>

The spring-boot-starter-data-jpa is a starter for using Spring Data JPA with Hibernate.

resources/application.properties

spring.main.banner-mode=off
logging.pattern.console=%clr(%d{yy-MM-dd E HH:mm:ss.SSS}){blue} %clr(%-5p) %clr(%logger{0}){blue} %clr(%m){faint}%n

The application.properties is the main Spring Boot configuration file. 

With the spring.main.banner-mode the property we turn off the Spring banner. The logging.pattern.console Defines the log pattern for the console.

JPA Entity - Employee.java

package net.guides.springboot.jparepository.model;

import jakarta.persistence.*;

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

    private long id;
    private String firstName;
    private String lastName;
    private String emailId;
 
    public Employee() {
  
    }
 
    public Employee(String firstName, String lastName, String emailId) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.emailId = emailId;
    }
 
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
 
    @Column(name = "first_name", nullable = false)
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
 
    @Column(name = "last_name", nullable = false)
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
 
    @Column(name = "email_address", nullable = false)
    public String getEmailId() {
        return emailId;
    }
    public void setEmailId(String emailId) {
        this.emailId = emailId;
    }

    @Override
    public String toString() {
        return "Employee [id=" + id + ", firstName=" + firstName + ", lastName=" + lastName + ", emailId=" + emailId
    + "]";
    }
 
}

JPA Repository - EmployeeRepository.java

The EmployeeRepository extends from the JpaRepository. It provides the type of the entity and of its primary key.

package net.guides.springboot.jparepository.repository;

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

import net.guides.springboot.jparepository.model.Employee;

@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Long>{

}

MyRunner.java

The MyRunner implements the CommandLineRunner interface and performs various database operations on Employee objects using the EmployeeRepository interface. This MyRunner class will be called whenever we start the Spring Boot application.

package net.guides.springboot.jparepository;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Component;

import net.guides.springboot.jparepository.model.Employee;
import net.guides.springboot.jparepository.repository.EmployeeRepository;

@Component
public class MyRunner implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(MyRunner.class);

    @Autowired
    private EmployeeRepository employeeRepository;

    @Override
    public void run(String... args) throws Exception {

     employeeRepository.save(new Employee("Ramesh", "Fadatare", "ramesh@gmail.com"));
     employeeRepository.save(new Employee("Tom", "Cruise", "tom@gmail.com"));
     employeeRepository.save(new Employee("John", "Cena", "john@gmail.com"));
     employeeRepository.save(new Employee("tony", "stark", "stark@gmail.com"));

        logger.info("# of employees: {}", employeeRepository.count());

        logger.info("All employees unsorted:");
        List<Employee> employees = employeeRepository.findAll();
        logger.info("{}", employees);

        logger.info("------------------------");

        logger.info("All employees sorted by name in descending order");
        List<Employee> sortedEmployees = employeeRepository.findAll(new Sort(Sort.Direction.DESC, "firstName"));
        logger.info("{}", sortedEmployees);

        logger.info("------------------------");

        logger.info("Deleting all employees");
        employeeRepository.deleteAllInBatch();

        logger.info("# of employees: {}", employeeRepository.count());
    }
}

Running Spring Boot Application

The Application sets up the Spring Boot application. Let's run this Application class:

package net.guides.springboot.jparepository;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
         SpringApplication.run(Application.class, args);
    }
}

Once you start the Spring boot application then it will call MyRunner class and executes its run() method.

Output

19-06-30 Sun 11:21:04.623 INFO  MyRunner # of employees: 4
19-06-30 Sun 11:21:04.623 INFO  MyRunner All employees unsorted:
19-06-30 Sun 11:21:04.666 INFO  MyRunner [Employee [id=1, firstName=Ramesh, lastName=Fadatare, emailId=ramesh@gmail.com], Employee [id=2, firstName=Tom, lastName=Cruise, emailId=tom@gmail.com], Employee [id=3, firstName=John, lastName=Cena, emailId=john@gmail.com], Employee [id=4, firstName=tony, lastName=stark, emailId=stark@gmail.com]]
19-06-30 Sun 11:21:04.667 INFO  MyRunner ------------------------
19-06-30 Sun 11:21:04.667 INFO  MyRunner All employees sorted by name in descending order
19-06-30 Sun 11:21:04.682 INFO  MyRunner [Employee [id=4, firstName=tony, lastName=stark, emailId=stark@gmail.com], Employee [id=2, firstName=Tom, lastName=Cruise, emailId=tom@gmail.com], Employee [id=1, firstName=Ramesh, lastName=Fadatare, emailId=ramesh@gmail.com], Employee [id=3, firstName=John, lastName=Cena, emailId=john@gmail.com]]
19-06-30 Sun 11:21:04.682 INFO  MyRunner ------------------------
19-06-30 Sun 11:21:04.682 INFO  MyRunner Deleting all employees
19-06-30 Sun 11:21:04.691 INFO  MyRunner # of employees: 0

← Back to Spring Boot Tutorial