Spring Boot CRUD REST APIs Validation Example

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

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

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

In this article, we will discuss how to customize the validation for REST API and we will use Hibernate Validator, which is one of the implementations of the bean validation API. We get Hibernate Validator for free when we use Spring Boot Starter Web.

Spring Boot provides a default implementation for handling errors and validations but sometimes we should return a proper error/validation response as per consumer requirement such as

A clear message indicating what went wrong? Which field has an error and what are the accepted values? What can the consumer do to fix the error?
Proper Response Status Bad Request.
Do not include sensitive information in the response.
Field validations/Bean validations

Steps to use Validation

1. Hibernate Validator available on the classpath when we use Spring Boot Starter Web.

2. Apply validation annotations to a bean. For example, @NotNull, @Email, @NotBlank, and @Size validations.

3. Enable validation on Spring Rest Controller by adding@Valid annotation in addition to @RequestBody.

4. To customize response validation we need to extend ResponseEntityExceptionHandler class and override handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatus status, WebRequest request) method.

Important Note:

Starting with Boot 2.3, we also need to explicitly add the spring-boot-starter-validation dependency:

<dependency> 
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-starter-validation</artifactId> 
</dependency>

If you are using Spring boot 2.3 +, make sure that you will use the above dependency to work with Hibernate validator.

In this example, we are using Spring boot 2.0.5 RELEASE so we get Hibernate Validator for free when we use Spring Boot Starter Web.

What we'll build?
Tools and Technologies Used
Creating and Importing a Project
The pom.xml File
Create JPA Entity and Implementing Validations on the Bean - Employee.java
Create Spring JPA Repository - EmployeeRepository.java
Create Spring Rest Controller and Enable Validation on Controller - EmployeeController.java
Exception(Error) Handling for RESTful Services
Running Application via Application.java
Testing via Postman Client
Source code on GitHub

1. What we'll build?

We will develop a simple Spring Boot RESTful CRUD APIs for the Employee resource and we will implement bean validation using Hibernate Validator.

2. Tools and Technologies Used

Spring Boot - 3+
JDK - 17 or later
Spring Framework - 6+
Maven - 3.2+
MySQL
IDE - Eclipse or Spring Tool Suite (STS)

3. Create a Spring Boot Project

There are many ways to create a Spring Boot application. The simplest way is to use Spring Initializr at http://start.spring.io/, which is an online Spring Boot application generator.

Create project packaging structure as per the below diagram:

4. The pom.xml File

Refer to the below pom.xml for your reference.

 <?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.springboot</groupId>
 <artifactId>springboot-crud-rest-api-validation</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>jar</packaging>
 
 <name>springboot-crud-rest-api-validation</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>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-validation</artifactId>
 </dependency>
 <dependency>
 <groupId>com.h2database</groupId>
 <artifactId>h2</artifactId>
 <scope>runtime</scope>
 </dependency>
 <dependency>
 <groupId>com.mysql</groupId>
 <artifactId>mysql-connector-j</artifactId>
 <scope>runtime</scope>
 </dependency>
 <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>

The next step is to create JPA Entity and apply validations on it - Employee.java

5. Create JPA Entity and Implementing Validations on the Bean - Employee.java

Let’s add a few validations to the employee bean. Note that we are using @NotNull, @Email, @NotBlank, and @Size validations.

 package net.guides.springboot.springbootcrudrestapivalidation.model;
 
 import jakarta.persistence.*;
 import jakarta.validation.constraints.Email;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Size;
 
 @Entity
 @Table(name = "employees")
 public class Employee {
 
 private long id;
 
 @NotNull
 @Size(min = 2, message = "First Name should have atleast 2 characters")
 private String firstName;
 
 @NotNull
 @Size(min = 2, message = "Last Name should have atleast 2 characters")
 private String lastName;
 
 @Email
 @NotBlank
 private String emailId;
 
 @NotNull
 @Size(min = 2, message = "Passport should have atleast 2 characters")
 private String passportNumber;
 
 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;
 }
 
 @Column(name = "passport_number", nullable = false)
 public String getPassportNumber() {
 return passportNumber;
 }
 
 public void setPassportNumber(String passportNumber) {
 this.passportNumber = passportNumber;
 }
 
 }

Next, we will create a Spring Data JPA repository - EmployeeRepository.java

6. Create Spring JPA Repository - EmployeeRepository.java

 package net.guides.springboot.springbootcrudrestapivalidation.repository;
 
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
 import net.guides.springboot.springbootcrudrestapivalidation.model.Employee;
 
 @Repository
 public interface EmployeeRepository extends JpaRepository<Employee, Long>{
 
 }

Let's configure MySQL properties in an application.properties

application.properties

spring.datasource.url = jdbc:mysql://localhost:3306/employees?useSSL=false
spring.datasource.username = root
spring.datasource.password = root
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQLDialect
spring.jpa.hibernate.ddl-auto = update

7. Create and Enable Validation on Spring Rest Controller - EmployeeController.java

Enabling Validation on the Resource

Add @Valid in addition to @RequestBody.

 @PostMapping("/employees")
 public Employee createEmployee(@Valid @RequestBody Employee employee) {
 return employeeRepository.save(employee);
 }

@Valid annotation enables the hibernate validation.

Let's create a complete EmployeeController class.

 package net.guides.springboot.springbootcrudrestapivalidation.controller;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import jakarta.validation.Valid;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 import net.guides.springboot.springbootcrudrestapivalidation.exception.ResourceNotFoundException;
 import net.guides.springboot.springbootcrudrestapivalidation.model.Employee;
 import net.guides.springboot.springbootcrudrestapivalidation.repository.EmployeeRepository;
 
 @RestController
 @RequestMapping("/api/v1")
 public class EmployeeController {
 @Autowired
 private EmployeeRepository employeeRepository;
 
 @GetMapping("/employees")
 public List<Employee> getAllEmployees() {
 return employeeRepository.findAll();
 }
 
 @GetMapping("/employees/{id}")
 public ResponseEntity<Employee> getEmployeeById(@PathVariable(value = "id") Long employeeId)
 throws ResourceNotFoundException {
 Employee employee = employeeRepository.findById(employeeId)
 .orElseThrow(() -> new ResourceNotFoundException("Employee not found for this id :: " + employeeId));
 return ResponseEntity.ok().body(employee);
 }
 
 @PostMapping("/employees")
 public Employee createEmployee(@Valid @RequestBody Employee employee) {
 return employeeRepository.save(employee);
 }
 
 @PutMapping("/employees/{id}")
 public ResponseEntity<Employee> updateEmployee(@PathVariable(value = "id") Long employeeId,
 @Valid @RequestBody Employee employeeDetails) throws ResourceNotFoundException {
 Employee employee = employeeRepository.findById(employeeId)
 .orElseThrow(() -> new ResourceNotFoundException("Employee not found for this id :: " + employeeId));
 
 employee.setEmailId(employeeDetails.getEmailId());
 employee.setLastName(employeeDetails.getLastName());
 employee.setFirstName(employeeDetails.getFirstName());
 final Employee updatedEmployee = employeeRepository.save(employee);
 return ResponseEntity.ok(updatedEmployee);
 }
 
 @DeleteMapping("/employees/{id}")
 public Map<String, Boolean> deleteEmployee(@PathVariable(value = "id") Long employeeId)
 throws ResourceNotFoundException {
 Employee employee = employeeRepository.findById(employeeId)
 .orElseThrow(() -> new ResourceNotFoundException("Employee not found for this id :: " + employeeId));
 
 employeeRepository.delete(employee);
 Map<String, Boolean> response = new HashMap<>();
 response.put("deleted", Boolean.TRUE);
 return response;
 }
 }

8. Exception(Error) Handling for RESTful Services

Spring Boot provides a good default implementation for exception handling for RESTful Services.

Let’s quickly look at the default Exception Handling features provided by Spring Boot.

Resource Not Present

Here is what happens when you fire a request to a resource not found: http://localhost:8080/some-dummy-url

{
 "timestamp": 1512713804164,
 "status": 404,
 "error": "Not Found",
 "message": "No message available",
 "path": "/some-dummy-url"
}

That's a cool error response. It contains all the details that are typically needed.

What happens when we throw an Exception?

Let’s see what Spring Boot does when an exception is thrown from a Resource. we can specify the Response Status for a specific exception along with the definition of the Exception with @ResponseStatus annotation.

Let's create a ResourceNotFoundException.java class.

 package net.guides.springboot.springbootcrudrestapivalidation.exception;
 
 import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.ResponseStatus;
 
 @ResponseStatus(value = HttpStatus.NOT_FOUND)
 public class ResourceNotFoundException extends Exception{
 
 private static final long serialVersionUID = 1L;
 
 public ResourceNotFoundException(String message){
 super(message);
 }
 }

Customizing Validation Response

Let’s define a simple validation response bean.

package net.guides.springboot.springbootcrudrestapivalidation.exception;
import java.util.Date;
public class ErrorDetails {
 private Date timestamp;
 private String message;
 private String details;
 public ErrorDetails(Date timestamp, String message, String details) {
 super();
 this.timestamp = timestamp;
 this.message = message;
 this.details = details;
 }
 public Date getTimestamp() {
 return timestamp;
 }
 public String getMessage() {
 return message;
 }
 public String getDetails() {
 return details;
 }
}

Create GlobalExceptionHandler class

Let’s now define a @ControllerAdvice to handle validation errors. We do that by overriding the handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatus status, WebRequest request) method in the ResponseEntityExceptionHandler.

 @Override
 protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex,
 HttpHeaders headers, HttpStatus status, WebRequest request) {
 ErrorDetails errorDetails = new ErrorDetails(new Date(), "Validation Failed",
 ex.getBindingResult().toString());
 return new ResponseEntity(errorDetails, HttpStatus.BAD_REQUEST);
 }

Let's put together global exception handling, a resource is not found exception handling and field validations logic in GlobalExceptionHandler.java file.

 package net.guides.springboot.springbootcrudrestapivalidation.exception;
 
 import java.util.Date;
 
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ControllerAdvice;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.context.request.WebRequest;
 import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
 
 @ControllerAdvice
 public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
 @ExceptionHandler(ResourceNotFoundException.class)
 public ResponseEntity<?> resourceNotFoundException(ResourceNotFoundException ex, WebRequest request) {
 ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), request.getDescription(false));
 return new ResponseEntity<>(errorDetails, HttpStatus.NOT_FOUND);
 }
 
 @ExceptionHandler(Exception.class)
 public ResponseEntity<?> globleExcpetionHandler(Exception ex, WebRequest request) {
 ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), request.getDescription(false));
 return new ResponseEntity<>(errorDetails, HttpStatus.INTERNAL_SERVER_ERROR);
 }
 
 @Override
 protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex,
 HttpHeaders headers, HttpStatus status, WebRequest request) {
 ErrorDetails errorDetails = new ErrorDetails(new Date(), "Validation Failed",
 ex.getBindingResult().toString());
 return new ResponseEntity(errorDetails, HttpStatus.BAD_REQUEST);
 } 
 }

9. Running Application

This spring boot application has an entry point Java class called SpringbootCrudRestApiValidationApplication.java with the public static void main(String[] args) method, which you can run to start the application.

 package net.guides.springboot.springbootcrudrestapivalidation;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication
 public class SpringbootCrudRestApiValidationApplication {
 
 public static void main(String[] args) {
 SpringApplication.run(SpringbootCrudRestApiValidationApplication.class, args);
 }
 }

10. Testing via Postman Client

Employee firstName field validation

Employee emailId field validation

Employee passportNumber field validation

11. Source code on GitHub

The source code of this article is available on my GitHub Repository on springboot-crud-rest-api-validation

Related Spring Boot and Microservices Tutorials/Guides:

(追記) (追記ここまで)

Spring Boot

Comments

Mingo 4 November 2020 at 05:16
Hello, I can't solve the problem with @Valid.

public Employee createEmployee(@Valid @RequestBody Employee employee)

"Valid cannot be resolved to a type"

And when I imported

import javax.validation.Valid;

"The import javax.validation cannot be resolved"
Reply Delete
Replies

Add comment

Spring 6 and Spring Boot 3 for Beginners (Includes 6 Projects)

Building Real-Time REST APIs with Spring Boot - Blog App

Building Microservices with Spring Boot and Spring Cloud

Full-Stack Java Development with Spring Boot 3 and React

Build 5 Spring Boot Projects with Java: Line-by-Line Coding

Testing Spring Boot Application with JUnit and Mockito

ChatGPT for Java Developers: Boost Your Productivity with AI

Spring Boot Thymeleaf Real-Time Web Application - Blog App

Master Spring Data JPA with Hibernate

Spring Boot + Apache Kafka Course - The Practical Guide

Java Testing: Mastering JUnit 5 Framework

Reactive Programming in Java: Spring WebFlux and Testing

Spring Boot + RabbitMQ Course - The Practical Guide

Free Courses on YouTube Channel