What is the purpose of the @Validated annotation?

Table of Contents

• Introduction
• Purpose of the @Validated Annotation
  • 1. Basic Functionality
    • Example: Simple Usage of @Validated
  • 2. Group-Based Validation with **@Validated**
    • Example: Group-Based Validation
  • 3. Applying Validation Groups with **@Validated**
    • Example: Applying Validation Groups in a Controller
  • 4. Differences Between **@Validated** and **@Valid**
    • Example: When to Use @Valid vs @Validated
• Practical Example: Group-Based Validation for Different Operations
• Conclusion

Introduction

In Spring-based applications, validating user input is essential to ensure data integrity and prevent errors. While @Valid is a commonly used annotation for performing validation in Spring, there is another annotation called @Validated that provides additional capabilities, especially for group-based validation. Understanding the purpose of @Validated and when to use it can help you implement more sophisticated validation logic in your Spring applications.

This guide will explain the purpose of the @Validated annotation, how it enhances validation functionality, and how to use it in Spring Boot applications for group-based validation.

Purpose of the @Validated Annotation

1. Basic Functionality

The @Validated annotation is part of the Spring Framework's validation mechanism. It is used to trigger validation on the target object in the same way as @Valid. The difference lies in the fact that @Validated is capable of validating specific groups of constraints, whereas @Valid performs validation without any group classification.

In most cases, @Validated is used in Spring controllers, service methods, or any other place where you need to validate a bean (such as in request bodies or method parameters).

Example: Simple Usage of @Validated

In this example, @Validated triggers the validation of the product object before the controller method is invoked.

2. Group-Based Validation with **@Validated**

The key advantage of @Validated over @Valid is its ability to support group-based validation. In many real-world scenarios, validation rules can vary depending on the context. For example, the validation rules for creating a new object might differ from those for updating an existing object.

With group-based validation, you can define different validation groups and apply them based on specific conditions. This allows you to validate different subsets of constraints on the same object, depending on the operation being performed.

Example: Group-Based Validation

To use group-based validation, you first define a group interface that marks different validation constraints.

Then, you apply the validation annotations to the model fields, specifying which group they belong to.

In this example:

• The name field will only be validated for the CreateGroup group when creating a product.
• The price field will be validated for both CreateGroup and UpdateGroup groups.
• The productCode field will only be validated for the CreateGroup group.

3. Applying Validation Groups with **@Validated**

Now, in your controller or service, you can specify which group to validate depending on the context, using the @Validated annotation.

Example: Applying Validation Groups in a Controller

In this example:

• The createProduct method validates the Product object using the CreateGroup group.
• The updateProduct method validates the Product object using the UpdateGroup group.

This ensures that only the relevant constraints for the specific operation are applied.

4. Differences Between **@Validated** and **@Valid**

While @Valid and @Validated are similar, the key difference lies in their support for validation groups:

• **@Valid**: Triggers validation for all constraints defined on the object.
• **@Validated**: Triggers validation for all constraints, but also allows you to specify validation groups for more granular control over which constraints should be applied.

If you need group-based validation, you must use @Validated over @Valid.

Example: When to Use @Valid vs @Validated

• If you want to validate the User object without considering groups (i.e., validate both the username and password fields), you can use @Valid:

• If you only want to validate fields for a specific group (e.g., when creating a user), you can use @Validated(CreateGroup.class):

Practical Example: Group-Based Validation for Different Operations

Let’s assume you have a model for a Product that requires different validation logic for creating and updating a product.

In your controller:

In this scenario:

• The createProduct method validates the product with the CreateGroup group.
• The updateProduct method validates the product with the UpdateGroup group.

Conclusion

The @Validated annotation is a powerful tool in Spring for performing input validation, especially when you need to support group-based validation. While @Valid performs standard validation without any grouping, @Validated provides the flexibility to apply different validation rules based on the operation being performed. By using @Validated in conjunction with validation groups, you can apply context-specific rules and ensure that your application handles input validation effectively.