How do you implement validation for REST API requests in Spring Boot?

Table of Contents

• Introduction
• Implementing Validation in Spring Boot
  • 1. Using the @Valid Annotation
    • Example: Applying @Valid with @RequestBody
  • 2. Handling Validation Errors
    • Example: Global Exception Handler
  • 3. Using Common Validation Annotations
    • Example: Validating a Product Object
  • 4. Validating Request Parameters
    • Example: Validating Query Parameters
• Practical Example: Complete Flow with Validation
• Conclusion

Introduction

Validating input data is crucial when building REST APIs in Spring Boot to ensure that the data sent by clients is correct and adheres to the expected format. Spring Boot provides a comprehensive validation mechanism using Java Bean Validation (JSR 303/JSR 380) annotations, such as @Valid, @NotNull, @Size, and many others, to perform automatic validation on the request body and parameters.

This guide covers how to implement validation for REST API requests in Spring Boot and integrate it with the @RequestBody or @RequestParam annotations for effective error handling and data validation.

Implementing Validation in Spring Boot

1. Using the @Valid Annotation

The @Valid annotation is used to trigger the validation process on an object. You can apply this annotation to method parameters, typically when binding incoming JSON data to a Java object.

Example: Applying @Valid with @RequestBody

In this example, we define a simple User class with validation annotations:

In your REST controller, use the @Valid annotation to trigger validation on the User object:

Now, when a client sends a POST request with invalid data, such as:

Spring Boot will automatically trigger validation errors, and you can handle them accordingly.

2. Handling Validation Errors

To handle validation errors gracefully, you can use an exception handler. You can define a @ControllerAdvice class that will catch validation exceptions and return a meaningful response to the client.

Example: Global Exception Handler

When invalid data is provided, the API will return a response like:

This ensures the user receives clear and actionable feedback about the validation errors.

3. Using Common Validation Annotations

Spring Boot supports many standard validation annotations for different scenarios. Some of the most common ones are:

• @NotNull: Ensures the field is not null.
• @Size: Specifies the allowed size of a string or collection.
• @Min and @Max: Ensure numeric fields are within a specified range.
• @Email: Ensures the field is a valid email address.
• @Pattern: Validates the field using a regular expression.

Example: Validating a Product Object

4. Validating Request Parameters

You can also validate request parameters using annotations such as @RequestParam, @PathVariable, etc., alongside @Valid.

Example: Validating Query Parameters

Here, the name parameter must be between 2 and 100 characters, and it cannot be null.

Practical Example: Complete Flow with Validation

1. User Entity (with validation):

2. Controller (with validation and global exception handling):

3. Sample Request (invalid data):

4. Response (validation errors):

Conclusion

Implementing validation for REST API requests in Spring Boot is essential to ensure that the data received from clients is valid and conforms to expected formats. Using annotations like @Valid, @NotNull, and @Size, you can easily validate the request body or parameters. Additionally, global exception handling ensures that validation errors are communicated clearly to the client. With these tools, you can build robust and secure APIs with minimal effort.