Spring MVC: How to perform validation?

Unraveling validation internals

Customized validation with Validator Interface

Spring's Validator interface allows you to sport your own custom validation logic. It's like being a bouncer at your own club, checking IDs under your own rules.

public class YourBouncer implements Validator {
    @Override
    public boolean supports(Class<?> clazz) {
        return FormData.class.equals(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
        // Quality control on your terms
    }
}


Hire your bouncer, I mean, bind your custom validator within the controller to set the rules of the game:

@InitBinder
protected void initBinder(WebDataBinder binder) {
    binder.setValidator(new YourBouncer()); // VIPs only
}


The art of complex validations: Field comparison and custom annotations

Validation is not always as straightforward as checking field length, sometimes fields need to be assessed in relation, like ensuring passwords match. Here, custom annotations such as @FieldsEquality come into play.

To implement this, we need the formidable ConstraintValidator:

public class FieldsEqualityValidator implements ConstraintValidator<FieldsEquality, Object> {
    @Override
    public boolean isValid(Object value, ConstraintValidatorContext context) {
        // Code to determine if "apple" is indeed an "apple", not an "orange"
    }
}


Validation errors in RESTful services: taming the beast with ControllerAdvice

Applying @Valid to your handler methods in a REST service then managing errors with ControllerAdvice can be as graceful as eating spaghetti with a spoon - but it's possible!

@ControllerAdvice
public class RestResponseEntityExceptionHandler extends ResponseEntityExceptionHandler {

    @Override
    protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
        // To err is human, to handle that error, divine!
    }
}


Visualization

Spring MVC Club (🌐)

• Guest 🚶 eager to enter the party.
• Bouncer (🔍: Spring Validator) applies scrutiny on the ID.

Validation verdict is in:

• VALID ID ✅: Let the party begin! 🎉
• INVALID ID ❌: Perhaps your dog can vouch for you? 🚫

Noteworthy steps in the validation journey:

1. Define the bouncer (Validator 🔍)
2. Sharpen your supports() and validate() tools
3. Launch auto-check with @Valid in your Controller method
4. Manage potential validation troubles 👮‍♂️

Pro tips and pitfalls

Mastering BindingResult

Cleanly separate validation and business logic using BindingResult. But remember, like a clingy partner, it's something you don't want to drag along further into your application layers.

@PostMapping("/submit")
public String submitForm(@Valid FormData formData, BindingResult bindingResult) {
    if (bindingResult.hasErrors()) {
        return "formPage";
    }
    // Drop the BindingResult here, like a hot potato!
}


Dependency injection in custom validators

If your custom validators need the magic of Spring-managed beans, remember that @Autowired is your trusty genie:

public class MyCustomValidator implements Validator {
    @Autowired
    private SomeDependency someDependency;

    // Now, isn't that validating?!
}


The traditional art of form model setup

When dealing with older Spring versions or XML-based configurations, remember to roll out the red carpet for form models:

@ModelAttribute("formData")
public FormData handshakeFormDataModel() {
    return new FormData();
}


This explicit name tag will prevent your model attribute from developing an identity crisis, leading to a smoother interaction between your view and controller.