_This post was originally published on [https://blog.tericcabrel.com](https://blog.tericcabrel.com/validate-request-body-and-parameter-in-spring-boot/)_ > Never trust user input A typical workflow of a Web application is: receive a request with some inputs, perform a treatment with the input received, and finally return a response. When developing our application, we usually test only the "happy path" or often think the end-user can't provide bad inputs. To prevent that, we can perform a validation of the inputs before processing the request. Spring offers an elegant way to do that, and we will see how to do it. ## The use case We need to build a system where a user can make a reservation for a room in a hotel. The user must provide his address information when registering. The possible actions are: * Register a user with his address. * Make a reservation for an existing user. Beneath is the Entity-Relation diagram of the system made with [drawSQL](https://drawsql.app/teco/diagrams/room-reservation): ![Minimal entity-relation diagram of a hotel reservation system](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ib7dkzrylrwmude2uvo8.png) ## Prerequisites For this tutorial, you need Java 11 and MySQL installed on your computer or [Docker](https://docs.docker.com/) if you don't want to install MySQL on your computer. Indeed, you can start a Docker container from MySQL Docker image. It will be enough to achieve the goal. ``` docker run -it -e MYSQL_ROOT_PASSWORD=secretpswd -e MYSQL_DATABASE=hotels --name hotels-mysql -p 3307:3306 mysql:8.0 ``` ## Setup the project Let's create a new spring project from [start.spring.io](https://start.spring.io/) with the required dependencies. ![Initialize the Spring Boot project with required dependencies](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bc3ri8jazrbiqrck0uc3.png) The dependency responsible for input validation is **Bean Validation with Hibernate validator**. Note that this library has no link with Hibernate's persistence aspect, provided here by Spring Data JPA. Open the project in your IDE and set the server port and database credentials in `application.properties` file. ``` server.port=4650 spring.datasource.url=jdbc:mysql://localhost:3307/hotels?serverTimezone=UTC&useSSL=false spring.datasource.username=root spring.datasource.password=secretpswd ## Hibernate properties spring.jpa.hibernate.use-new-id-generator-mappings=false spring.jpa.hibernate.ddl-auto=update spring.jpa.show-sql=false spring.jpa.open-in-view=false ``` ## Create entities and services We need to create the entities **User, Address, and Reservation**. For each entity, we will create the related Repository and Service. Since it is not the main topic of this tutorial, find the code of these files in the [Github repository](https://github.com/tericcabrel/blog-tutorials/tree/main/springboot-validation): * Entities are inside the package **models**. * Entities Repositories are inside the package **repositories**. * Services are inside the package **services**. ## Register a user We need to create the endpoint to handle this action and also define the object that will receive the input required to create the user. ## Create the model for the request body When registering a new user, we also provide information on his address in the body. We need to structure our object to handle that by creating a class called AddressDTO that will hold all properties for the address, and there will be a property of type AddressDTO inside the class RegisterUserDTO. The class names are suffixed with [DTO (Data Transfer Object)](https://en.wikipedia.org/wiki/Data_transfer_object) because they transport data from one layer (controller) to another layer (persistence). A common use case of his usage is when we need to apply some transformation data before passing them to the other layer. I will write a more detailed post about it later. Create a package called **dtos** inside the package **models**, then create two classes **AddressDto.java** and **RegisterUserDto.java**. ## Add validation Hibernate Validator provides built-in constraints that will use to validate our input. To see the full list check out this [link](https://docs.jboss.org/hibernate/stable/validator/reference/en-US/html_single/#section-builtin-constraints). **AddressDto.java** ``` package com.tericcabrel.hotel.models.dtos; import com.tericcabrel.hotel.models.Address; import javax.validation.constraints.NotBlank; import javax.validation.constraints.Pattern; import javax.validation.constraints.Pattern.Flag; import lombok.Data; @Data public class AddressDto { @NotBlank(message = "The country is required.") private String country; @NotBlank(message = "The city is required.") private String city; @NotBlank(message = "The Zip code is required.") @Pattern(regexp = "^\\d{1,5}$", flags = { Flag.CASE_INSENSITIVE, Flag.MULTILINE }, message = "The Zip code is invalid.") private String zipCode; @NotBlank(message = "The street name is required.") private String street; private String state; public Address toAddress() { return new Address() .setCountry(country) .setCity(city) .setZipCode(zipCode) .setStreet(street) .setState(state); } } ``` **RegisterUserDto.java** ``` package com.tericcabrel.hotel.models.dtos; import com.tericcabrel.hotel.models.User; import java.util.Date; import javax.validation.Valid; import javax.validation.constraints.Email; import javax.validation.constraints.NotEmpty; import javax.validation.constraints.NotNull; import javax.validation.constraints.Past; import javax.validation.constraints.Pattern.Flag; import javax.validation.constraints.Size; import lombok.Data; @Data public class RegisterUserDto { @NotEmpty(message = "The full name is required.") @Size(min = 2, max = 100, message = "The length of full name must be between 2 and 100 characters.") private String fullName; @NotEmpty(message = "The email address is required.") @Email(message = "The email address is invalid.", flags = { Flag.CASE_INSENSITIVE }) private String email; @NotNull(message = "The date of birth is required.") @Past(message = "The date of birth must be in the past.") private Date dateOfBirth; @NotEmpty(message = "The gender is required.") private String gender; @Valid @NotNull(message = "The address is required.") private AddressDto address; public User toUser() { return new User() .setName(fullName) .setEmail(email.toLowerCase()) .setBirthDate(dateOfBirth) .setGender(gender) .setAddress(address.toAddress()); } } ``` ## Create a route to test registration Let's create an endpoint responsible for registering a new user. Create a package called **controllers**, then create a controller called **UserController.java**. Add the code below: ``` package com.tericcabrel.hotel.controllers; /* CLASSES IMPORT HERE */ @RequestMapping(value = "/user") @RestController public class UserController { private final UserService userService; public UserController(UserService userService) { this.userService = userService; } @PostMapping("/register") public ResponseEntity registerUser(@Valid @RequestBody RegisterUserDto registerUserDto) { User createdUser = userService.create(registerUserDto.toUser()); return new ResponseEntity<>(createdUser, HttpStatus.CREATED); } } ``` The most important part of the code above is the use of the **@Valid** annotation. **When Spring finds an argument annotated with @Valid, it automatically validates the argument and throws an exception if the validation fails**. Run the application and make sure there is no error at the launch. ## Test with postman Our app launched; open postman and send a request with all the input to null and see the result. ![Register user with invalid information](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cnv4yxxhmyhr9xchfbmv.png) We got an HTTP status 400 with the message "Bad Request," nothing more 🙁. Let's check the application console to see what happened: ![Validation error message printed](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/oflyhvlcv70wlsdxrazx.png) As we can see, an exception of type **MethodArgumentNotValidException** has been thrown, but since the exception is not caught anywhere, the response fallback to a Bad Request. ## Handle validation error exception Spring provides a specialized annotation of **@Component** called **@ControllerAdvice** which allows handling exceptions thrown by methods annotated with **@RequestMapping** and similar in one global single component. Create a package called **exceptions**, then create a file called **GlobalExceptionHandler.java**. Add the code below: ``` package com.tericcabrel.hotel.exceptions; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.stream.Collectors; import org.springframework.context.support.DefaultMessageSourceResolvable; 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.context.request.WebRequest; import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler; @ControllerAdvice public class GlobalExceptionHandler extends ResponseEntityExceptionHandler { @Override protected ResponseEntity

tericcabrel

Validate Request Body and Parameter in Spring Boot

Join Our Newsletter. No Spam, Only the good stuff.