JPA Repository Find By Date Range

In the JPA Repository, we can find by date range by using the finder method of Spring Data JPA with the Between keyword to fetch records from the database. To create a finder method start with findBy followed by property_name  of the JPA Entity class then add the Between keyword in the finder method[findByPropertyNameBetween()] of JPA Repository. In this topic, we will learn how to fetch records from the database using find by date range in the JPA Repository using Spring Boot, Maven, Spring Web, Lombok, Spring Data JPA and H2 database.


Let’s create a Spring Boot restful web services application to implement the JPA Repository find by date range step-by-step.

These are the following steps:

  1. Creating a Spring Boot Starter Project
  2. Keep the IDE ready
  3. Maven Dependency
  4. Defining the configuration
  5. Creating a JPA Entity
  6. Creating a JPA Repository
  7. Creating a Service Interface
  8. Creating a Service class
  9. Creating a Rest Controller class
  10. Run the Spring Application and Check

1. Creating a Spring Boot Starter Project

 We are creating a Spring Boot Application from the web tool Spring Initializr or you can create it from the IDE(STS, VS Code etc.) you are using. 

Add the following dependencies: 

  • Spring Web
  • Spring Data JPA
  • Lombok
  • H2 Database

2. Keep the IDE ready

We are importing this created application into our Eclipse IDE or you can import it into another IDE you use. You can refer to this article to create and set up the Spring Boot Project in Eclipse IDE.

Project Structure of Find by date range


3. Maven Dependency

Here is the complete pom.xml file for the Spring Boot Application.

<?xml version="1.0" encoding="UTF-8"?>

		<relativePath />
		<!-- lookup parent from repository -->
	<description>Demo project for Spring Boot</description>

4. Defining the configuration

We are configuring the H2 database configuration in the file.

# H2 Database Configuration

5. Creating a JPA Entity

We are creating a JPA entity class Employee with these properties(id, firstName, lastName, department and hireDate).

package com.springjava.entity;

import java.time.LocalDate;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import lombok.Data;



public class Employee {


  @GeneratedValue(strategy = GenerationType.IDENTITY)

  private Long id;

  private String firstName;

  private String lastName;

  private String department;

  private LocalDate hireDate;

  • This @Data annotation is used for a constructor, setter method, getter method, etc.
  • This @Entity annotation is used to create a table through Java code in the database.

6. Creating a JPA Repository

We are creating a JPA Repository to interact with the JPA Entity class and adding a finder method with the hireDate property name[findByHireDateBetween(LocalDate fromDate, LocalDate toDate)].

package com.springjava.repository;

import java.time.LocalDate;

import java.util.List;


import com.springjava.entity.Employee;

public interface EmplRepository extends JpaRepository < Employee, Long > {

List < Employee > findByHireDateBetween(LocalDate fromDate, LocalDate toDate);


7. Creating a Service Interface

We are creating a Service interface with some method declaration[save(Employee employee) and getByHireDate(LocalDate fromDate, LocalDate toDate)]. So the implementation class of this interface overrides these declared methods.

package com.springjava.service;

import java.time.LocalDate;

import java.util.List;

import com.springjava.entity.Employee;

public interface EmployeeService {

  void save(Employee employee);

  List < Employee > getByHireDate(LocalDate fromDate, LocalDate toDate);


8. Creating a Service class

We are creating a Service class EmployeeServiceImpl and this class is implementing the EmployeeService interface. This class is annotated with @Service annotation to act service.

package com.springjava.service;

import java.time.LocalDate;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import com.springjava.entity.Employee;

import com.springjava.repository.EmplRepository;


public class EmployeeServiceImpl implements EmployeeService {


  EmplRepository empRepo;


  public void save(Employee employee) {;



  public List < Employee > getByHireDate(LocalDate fromDate, LocalDate toDate) {

    return empRepo.findByHireDateBetween(fromDate, toDate);


  • We used @Autowired annotation to inject the EmplRepository in this service class.
  • We used save() and findByHireDateBetween() query methods of that JPA Repository.

9. Creating a Rest Controller class

We are creating a RestController class EmployeeController in which all methods are created for API endpoints for handling client requests. 

package com.springjava.controller;

import java.time.LocalDate;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import com.springjava.entity.Employee;

import com.springjava.service.EmployeeService;



public class EmployeeController {


  EmployeeService empService;


  public ResponseEntity < ? > save(@RequestBody Employee employee) {

    Map < String, Object > respEmp = new LinkedHashMap < String, Object > ();


    respEmp.put("status", 1);

    respEmp.put("message", "Record is Saved Successfully!");

    return new ResponseEntity < > (respEmp, HttpStatus.CREATED);



  public ResponseEntity < ? > getByHireDate() {

    Map < String, Object > respEmp = new LinkedHashMap < String, Object > ();

    List < Employee > emList = empService.getByHireDate(,;

    if (!emList.isEmpty()) {

      respEmp.put("status", 1);

      respEmp.put("data", emList);

      return new ResponseEntity < > (respEmp, HttpStatus.OK);

    } else {


      respEmp.put("status", 0);

      respEmp.put("message", "Data is not found");

      return new ResponseEntity < > (respEmp, HttpStatus.NOT_FOUND);



  • This class is annotated with @RestController annotation to make this class act as Rest Controller for giving responses in JSON form.
  • We used @RequestMapping annotation to define the base URL for the application.
  • We used @PostMapping and @GetMapping annotations to handle HTTP requests from the client.
  • We used ResponseEntity to represent the entire HTTP response.
  • We used @Autowired  annotation to inject EmployeeService in the class.
  • We used @RequestBody annotation to take JSON object in the save() method as the parameter of the Employee class.
  • We used for the current date.
  • We have created two restful web services handling methods(save() and getByHireDate()).
  • save(): This saves Employee records into the database.
  • getByHireDate(): This fetches a list of employee records by passing the LocalDate values as a parameter.

10. Run the Spring Boot Application and Check

Right-click this Spring Boot application on the, then click Run As and select Java Application. 

Check H2 Database

Check the H2 database console and browse this URL “http://localhost:8080/h2-console”.


See the below table here:


Testing API on the Postman

Saving the employee data

POST: http://localhost:8080/api/employee/save


Check the table:

Retrieving the user by an enum value

GET: http://localhost:8080/api/employee/find-by-date-range

After this API hit Spring Data JPA (internally uses Hibernate as a JPA provider) generated SQL statement in the console below here:

select as id1_0_, 
employee0_.department as departme2_0_, 
employee0_.first_name as first_na3_0_, 
employee0_.hire_date as hire_dat4_0_, 
employee0_.last_name as last_nam5_0_ 
employee employee0_ 
employee0_.hire_date between ? and ?


In this topic, we learnt how to use the date range in findBy() method of JPA Repository to get records from the database in Spring Boot Restful web services application.

Leave a Comment