JPA Repository Find By Enum

by

Last updated on May 1st, 2024

To use the find by enum in the JPA Repository to fetch records according to it. For this, we need to create a JPA Entity class with an enum-type property, and then we can create a findBy() method with that enum property name of that entity class in the JPA Repository. After that, we can use that method to select records from the database as per the enum value. In this topic, we will learn how to use findBy() method with an enum property value to get records using Spring Boot, Maven, Spring Web, Spring Data JPA Lombok and H2 database.

find_by_enum

Let’s create a step-by-step Spring Boot restful web service application to implement findBy() method with the enum property name of the JPA entity in the JPA Repository to get records.

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 an Enum
  6. Creating a JPA Entity
  7. Creating a JPA Repository
  8. Creating a Service Interface
  9. Creating a Service class
  10. Creating a Rest Controller class
  11. 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 are using. You can refer to this article to create and set up the Spring Boot Project in Eclipse IDE.

Project Structure of Find By Enum Value

3. Maven Dependency

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

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.6.3</version>
		<relativePath />
		<!-- lookup parent from repository -->
	</parent>
	<groupId>com.springjava</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency></dependency>
		<groupId>com.h2database</groupId>
		<artifactId>h2</artifactId>
		<scope>runtime</scope>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

4. Defining the configuration

We are configuring the H2 database configuration in the application.properties file.

application.properties

# H2 Database Configuration
spring.datasource.url=jdbc:h2:mem:test
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update
spring.h2.console.enabled=true

5. Creating an Enum

We are an enum Status with these values(ACTIVE,  INACTIVE, SUSPENDED).

Status.java

package com.springjava.enums;

public enum Status {

  ACTIVE,
  INACTIVE,
  SUSPENDED

}

6. Creating a JPA Entity

We are creating a JPA entity class User with these properties(id, name and status).

User.java

package com.springjava.entity;

import javax.persistence.Entity;

import javax.persistence.EnumType;

import javax.persistence.Enumerated;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import com.springjava.enums.Status;

import lombok.Data;

@Data

@Entity

public class User {

  @Id

  @GeneratedValue(strategy = GenerationType.IDENTITY)

  private Long id;

  private String name;

  @Enumerated(EnumType.STRING)

  private Status status;

}
  • 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.
  • This @Enumerated(EnumType.STRING) stores an enum as a String in the database. 

7. Creating a JPA Repository

We are creating a JPA Repository to interact with the JPA Entity class and adding a finder method with the enum property name[findByStatus(Status status)].

UserRepository.java

package com.springjava.repository;

import java.util.List;

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

import com.springjava.entity.User;

import com.springjava.enums.Status;

public interface UserRepository extends JpaRepository<User, Long> {

List<User> findByStatus(Status status);

}

8. Creating a Service Interface

We are creating a Service interface with some method declaration[save(User user) and getByStatus(Status status)]. So the implementation class of this interface overrides these declared methods in there.

UserService.java

package com.springjava.service;

import java.util.List;

import com.springjava.entity.User;

import com.springjava.enums.Status;

public interface UserService {

  void save(User user);

  List < User > getByStatus(Status status);

}

9. Creating a Service class

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

UserServiceImpl.java

package com.springjava.service;

import java.util.List;

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

import org.springframework.stereotype.Service;

import com.springjava.entity.User;

import com.springjava.enums.Status;

import com.springjava.repository.UserRepository;

@Service

public class UserServiceImpl implements UserService {

  @Autowired

  private UserRepository userRepo;

  @Override

  public void save(User user) {

    userRepo.save(user);

  }

  @Override

  public List < User > getByStatus(Status status) {

    return userRepo.findByStatus(status);

  }

}
  • We used @Autowired annotation to inject UserRepository in this service class.
  • We used save() and findByStatus() query methods of that JPA Repository.

10. Creating a Rest Controller class

We are creating a RestController class UserController in which all methods are created for API endpoints for handling requests from the clients. 

UserController.Java

package com.springjava.controller;

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.User;

import com.springjava.enums.Status;

import com.springjava.service.UserService;

@RestController

@RequestMapping("/api/user")

public class UserController {

@Autowired

private UserService userService;

@PostMapping("/save")

public ResponseEntity<?> save(@RequestBody User user) {

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

userService.save(user);

respUser.put("status", 1);

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

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

}

@GetMapping("/find-by-enum")

public ResponseEntity<?> getByStatus() {

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

List<User> userList= userService.getByStatus(Status.ACTIVE);

if (!userList.isEmpty()) {

respUser.put("status", 1);

respUser.put("data", userList);

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

} else {

respUser.clear();

respUser.put("status", 0);

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

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

}

}

}
  • This class is annotated with @RestController annotation to make this class act as a 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 UserService into the class.
  • We used @RequestBody annotation to take JSON object in the save() method as the User class parameter.
  • We have created two restful web services handling methods(save() and getByStatus()).
  • save(): This saves user records into the database.
  • getByStatus(): This fetches a list of User records by passing the Status.ACTIVE  value as a parameter.

11. Run the Spring Boot Application and Check

Right-click this Spring Boot application on the DemoApplication.java, 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”.

find_by_enum

See the below table here:

find_by_enum

Testing API on the Postman

Saving the user data

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

find_by_enum

Check the table:

find_by_enum

Retrieving the user by an enum value

GET: http://localhost:8080/api/user/find-by-enum

find_by_enum

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

Hibernate: 
select user0_.id as id1_0_, 
user0_.name as name2_0_, 
user0_.status as status3_0_ 
from 
user user0_ 
where 
user0_.status=?

Conclusion

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

Leave a Comment