What is @Validated Annotation in Spring Boot?

@Validated is an annotation in Spring Boot used to trigger validation on method parameters, request objects, service-layer methods, and validation groups.

It is an advanced version of @Valid and provides additional features such as:

• Validation groups
• Method-level validation
• Service-layer validation
• Parameter validation

In simple words, @Validated tells Spring Boot:

“Validate this object or method parameters before processing.”

---

Why is @Validated Used?

Applications receive data from:

• REST API requests
• Forms
• Service methods
• Microservices communication
• User input fields

Invalid data can cause:

• Database corruption
• Business rule failures
• Application crashes
• Security issues

@Validated helps ensure only valid data is processed.

---

Package of @Validated

import org.springframework.validation.annotation.Validated;

---

Validation Dependency

To use validation in Spring Boot:

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

---

How @Validated Works Internally

When validation is triggered:

1. Spring Boot intercepts method execution
2. Validation framework checks annotations
3. Hibernate Validator validates fields
4. If validation succeeds, method executes
5. If validation fails, exception is thrown

---

Simple Example of @Validated

DTO Class

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;

public class UserRequest {

    @NotBlank(message = "Name is required")
    private String name;

    @Email(message = "Invalid email")
    private String email;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

---

Controller Example

@RestController
@RequestMapping("/users")
@Validated
public class UserController {

    @PostMapping
    public String createUser(
            @RequestBody @Validated UserRequest request) {

        return "User Created Successfully";
    }
}

---

Valid Request

{
   "name": "Naresh",
   "email": "naresh@gmail.com"
}

---

Output

User Created Successfully

---

Invalid Request

{
   "name": "",
   "email": "abc"
}

---

Validation Error

{
   "status": 400,
   "errors": [
      "Name is required",
      "Invalid email"
   ]
}

---

Method Parameter Validation Using @Validated

One major advantage of @Validated is method parameter validation.

Example

@RestController
@RequestMapping("/products")
@Validated
public class ProductController {

    @GetMapping("/{id}")
    public String getProduct(
            @PathVariable
            @Min(value = 1, message = "Id must be positive")
            int id) {

        return "Product Id: " + id;
    }
}

---

Invalid Request

http://localhost:8080/products/0

---

Validation Error

{
   "status": 400,
   "message": "Id must be positive"
}

---

Why @Validated is Required for Method Validation

Method parameter validation works only when:

• The class contains @Validated
• Validation annotations are added on parameters

Without @Validated, method-level validation will not trigger.

---

Validation Groups in @Validated

One of the biggest advantages of @Validated is support for validation groups.

Validation groups allow different validation rules for different operations.

Example:

• Create operation
• Update operation

---

Step-by-Step Validation Group Example

Step 1: Create Group Interfaces

public interface CreateValidation {
}

public interface UpdateValidation {
}

---

Step 2: DTO Class

public class ProductRequest {

    @NotNull(
            groups = UpdateValidation.class,
            message = "Id is required for update"
    )
    private Integer id;

    @NotBlank(
            groups = {
                    CreateValidation.class,
                    UpdateValidation.class
            },
            message = "Product name is required"
    )
    private String name;
}

---

Step 3: Controller

@RestController
@RequestMapping("/products")
public class ProductController {

    @PostMapping
    public String createProduct(
            @RequestBody
            @Validated(CreateValidation.class)
            ProductRequest request) {

        return "Product Created";
    }

    @PutMapping
    public String updateProduct(
            @RequestBody
            @Validated(UpdateValidation.class)
            ProductRequest request) {

        return "Product Updated";
    }
}

---

Benefits of Validation Groups

• Different rules for different operations
• Cleaner validation design
• Improved flexibility
• Better enterprise application support

---

Difference Between @Valid and @Validated

Feature	@Valid	@Validated
Basic Validation	Yes	Yes
Validation Groups	No	Yes
Method Validation	Limited	Yes
Service Layer Validation	No	Yes
Main Usage	Simple DTO validation	Advanced validation

---

Using @Validated in Service Layer

@Validated is commonly used in service classes.

Example

@Service
@Validated
public class PaymentService {

    public void processPayment(
            @Min(value = 1, message = "Amount must be positive")
            double amount) {

        System.out.println("Payment Processed");
    }
}

---

Real-Time Example in Banking Application

Suppose a banking application processes money transfer requests.

DTO Class

public class TransferRequest {

    @NotBlank(message = "Account number is required")
    private String accountNumber;

    @Positive(message = "Transfer amount must be positive")
    private double amount;
}

---

Controller

@RestController
@RequestMapping("/transfer")
@Validated
public class TransferController {

    @PostMapping
    public String transferMoney(
            @RequestBody
            @Validated TransferRequest request) {

        return "Transfer Successful";
    }
}

---

Advantages of @Validated

• Supports advanced validation
• Supports validation groups
• Enables method-level validation
• Works at service layer
• Improves data integrity
• Reduces manual validation code
• Supports enterprise-grade applications

---

Disadvantages of @Validated

• Complex validation groups may increase complexity
• Improper configuration may disable validation
• Too many validation rules may affect readability

---

Common Exceptions in Validation

Exception	Description
MethodArgumentNotValidException	Request body validation failure
ConstraintViolationException	Method parameter validation failure

---

Best Practices for Using @Validated

• Use validation groups carefully
• Use DTO classes instead of entities
• Handle validation exceptions globally
• Use meaningful validation messages
• Validate all external user input
• Use @Validated for service-layer validation

---

Common Interview Questions on @Validated

What is @Validated in Spring Boot?

@Validated is an annotation used for advanced validation, including validation groups and method-level validation.

What is the difference between @Valid and @Validated?

@Validated supports validation groups and method validation, while @Valid is mainly used for basic object validation.

Why is @Validated used at class level?

It enables method parameter validation in controllers and services.

Can @Validated be used in service classes?

Yes. It is commonly used for service-layer validation.

What exception occurs during method parameter validation?

ConstraintViolationException usually occurs.

---

Conclusion

@Validated is a powerful validation annotation in Spring Boot used for advanced validation scenarios.

It supports validation groups, method-level validation, service-layer validation, and enterprise-grade validation design.

Compared to @Valid, @Validated provides greater flexibility and is widely used in large-scale enterprise applications, microservices, and production systems.

Understanding @Validated is essential for Spring Boot developers because validation is a critical part of secure, scalable, and reliable backend application development.