Using @Valid Annotation for Simplified Form Validation in Spring Boot

In a recent conversation with a developer friend, the author highlighted the pain of writing repetitive manual validation code for Spring Boot form inputs and introduced the @Valid annotation as a concise solution.

Traditional Spring validation often requires explicit checks for each field, leading to lengthy and error‑prone code. An example of such manual validation is shown below:

public String registerUser(String username, String email) {
    if (username == null || username.isEmpty()) {
        throw new IllegalArgumentException("Username is required");
    }
    if (email == null || !email.matches("^[A-Za-z0-9+_.-]+@(.+)$")) {
        throw new IllegalArgumentException("Invalid email format");
    }
    // other validation logic
    return "Registration successful";
}

Spring Boot’s @Valid annotation allows developers to declare validation rules on beans, letting the framework automatically perform the checks and throw appropriate exceptions, thus eliminating the need for such boilerplate.

For instance, a User class can be defined with standard validation annotations:

import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Email;

public class User {
    @NotEmpty(message = "Username cannot be empty")
    private String username;

    @Email(message = "Invalid email format")
    private String email;
    // getters and setters
}

In a controller, the @Valid annotation is applied to the request body, and Spring automatically validates the incoming User object:

@PostMapping("/register")
public String registerUser(@Valid @RequestBody User user) {
    // If validation fails, Spring throws MethodArgumentNotValidException
    return "Registration successful";
}

When validation fails, Spring throws a MethodArgumentNotValidException , so developers no longer need to write explicit error‑handling logic for each field.

Beyond built‑in constraints, developers can create custom validation annotations. The following example defines a custom @ValidEmailDomain annotation and its validator:

@Target({ ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = EmailDomainValidator.class)
public @interface ValidEmailDomain {
    String message() default "Invalid email domain";
    Class
[] groups() default {};
    Class
[] payload() default {};
}

public class EmailDomainValidator implements ConstraintValidator
{
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        return value != null && value.endsWith("@example.com");
    }
}

Custom validators enable flexible, business‑specific rules without altering existing code structures.

The article also lists four key advantages of using @Valid :

Simplifies validation logic : Spring automatically triggers bean validation, removing the need for manual checks.

Improves development efficiency : Reduces repetitive code, allowing developers to focus on business logic.

Enhances code readability : Annotation‑based rules make the code cleaner and easier to maintain.

Supports flexible extensions : In addition to standard constraints, custom validators can be added to meet complex requirements.

In a real e‑commerce project, the team replaced a large amount of manual validation with @Valid , resulting in shorter, clearer controller methods:

@PostMapping("/register")
public String registerUser(@Valid @RequestBody User user) {
    return "User registered successfully";
}

Overall, the @Valid annotation is a powerful tool in Spring Boot that streamlines form validation, reduces boilerplate, and boosts developer productivity.