What does the Valid annotation indicate in Spring

Question

In the following example  the ScriptFile parameter is marked with an  Valid annotation   What does  Valid annotation do    RequestMapping value     scriptfile   method   RequestMethod POST      public String create  Valid ScriptFile scriptFile  BindingResult result  ModelMap modelMap            if  scriptFile    null  throw new IllegalArgumentException  A scriptFile is required                if  result hasErrors                      modelMap addAttribute  scriptFile   scriptFile                       modelMap addAttribute  showcases   ShowCase findAllShowCases                         return  scriptfile create                                 scriptFile persist                return  redirect  scriptfile     scriptFile getId

User · Answer

I think I know where your question is headed. And since this question is the one that pop ups in google's search main results, I can give a plain answer on what the @Valid annotation does.

I'll present 3 scenarios on how I've used @Valid

Model:

public class Employee{
private String name;
@NotNull(message="cannot be null")
@Size(min=1, message="cannot be blank")
private String lastName;
 //Getters and Setters for both fields.
 //...
}

JSP:

...
<form:form action="processForm" modelAttribute="employee">
 <form:input type="text" path="name"/>
 <br>
 <form:input type="text" path="lastName"/>
<form:errors path="lastName"/>
<input type="submit" value="Submit"/>
</form:form>
...

Controller for scenario 1:

     @RequestMapping("processForm")
        public String processFormData(@Valid @ModelAttribute("employee") Employee employee){
        return "employee-confirmation-page";
    }

In this scenario, after submitting your form with an empty lastName field, you'll get an error page since you're applying validation rules but you're not handling it whatsoever.

Example of said error: Exception page

Controller for scenario 2:

 @RequestMapping("processForm")
    public String processFormData(@Valid @ModelAttribute("employee") Employee employee,
BindingResult bindingResult){
                return bindingResult.hasErrors() ? "employee-form" : "employee-confirmation-page";
            }

In this scenario, you're passing all the results from that validation to the bindingResult, so it's up to you to decide what to do with the validation results of that form.

Controller for scenario 3:

@RequestMapping("processForm")
    public String processFormData(@Valid @ModelAttribute("employee") Employee employee){
                return "employee-confirmation-page";
            }
@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public Map<String, String> invalidFormProcessor(MethodArgumentNotValidException ex){
  //Your mapping of the errors...etc
}

In this scenario you're still not handling the errors like in the first scenario, but you pass that to another method that will take care of the exception that @Valid triggers when processing the form model. Check this see what to do with the mapping and all that.

To sum up: @Valid on its own with do nothing more that trigger the validation of validation JSR 303 annotated fields (@NotNull, @Email, @Size, etc...), you still need to specify a strategy of what to do with the results of said validation.

Hope I was able to clear something for people that might stumble with this.

User · Answer

IIRC  Valid isn t a Spring annotation but a JSR-303 annotation  which is the Bean Validation standard   What it does is it basically checks if the data that you send to the method is valid or not  it will validate the scriptFile for you

User · Answer

Just adding to the above answer  In a web application  valid is used where the bean to be validated is also annotated with validation annotations e g   NotNull   Email hibernate annotation  so when while getting input from user the values can be validated and binding result will have the validation results  bindingResult hasErrors   will tell if any validation failed

User · Answer

Valid in itself has nothing to do with Spring  It s part of Bean Validation specification there are several of them  the latest one being JSR 380 as of second half of 2017   but  Valid is very old and derives all the way from JSR 303   As we all know  Spring is very good at providing integration with all different JSRs and java libraries in general think of JPA  JTA  Caching  etc   and of course those guys took care of validation as well  One of the key components that facilitates this is MethodValidationPostProcessor   Trying to answer your question -  Valid is very handy for so called validation cascading when you want to validate a complex graph and not just a top-level elements of an object  Every time you want to go deeper  you have to use  Valid  That s what JSR dictates  Spring will comply with that with some minor deviations for example I tried putting  Validated instead of  Valid on RestController method and validation works  but the same will not apply for a regular  service  beans

User · Answer

It s for validation purposes      Validation It is common to validate a   model after binding user input to it    Spring 3 provides support for   declarative validation with JSR-303    This support is enabled automatically   if a JSR-303 provider  such as   Hibernate Validator  is present on   your classpath  When enabled  you can   trigger validation simply by   annotating a Controller method   parameter with the  Valid annotation    After binding incoming POST   parameters  the AppointmentForm will   be validated  in this case  to verify   the date field value is not null and   occurs in the future     Look here for more info  http   blog springsource com 2009 11 17 spring-3-type-conversion-and-validation

User · Answer

Adding to above answers  take a look at following  AppointmentForm s date column is annotated with couple of annotations  By having  Valid annotation that triggers validations on the AppointmentForm  in this case  NotNull and  Future   These annotations could come from different JSR-303 providers  e g  Hibernate  Spring  etc         RequestMapping value     appointments   method   RequestMethod POST      public String add  Valid AppointmentForm form  BindingResult result                            static class AppointmentForm             NotNull  Future         private Date date

User · Answer

I wanted to add more details about how the  Valid works  especially in spring  Everything you d want to know about validation in spring is explained clearly and in detail in https   reflectoring io bean-validation-with-spring-boot   but I ll copy the answer to how  Valid works incase the link goes down  The  Valid annotation can be added to variables in a rest controller method to validate them  There are 3 types of variables that can be validated   the request body  variables within the path  e g  id in  foos  id   and  query parameters   So now    how does spring  quot validate quot   You can define constraints to the fields of a class by annotating them with certain annotations  Then  you pass an object of that class into a Validator which checks if the constraints are satisfied  For example  suppose I had controller method like this   RestController class ValidateRequestBodyController       PostMapping  quot  validateBody quot     ResponseEntity lt String gt  validateBody  Valid  RequestBody Input input        return ResponseEntity ok  quot valid quot            So this is a POST request which takes in a response body  and we re mapping that response body to a class Input  Here s the class Input  class Input       Min 1     Max 10    private int numberBetweenOneAndTen      Pattern regexp    quot   0-9  1 3     0-9  1 3     0-9  1 3     0-9  1 3   quot     private String ipAddress                 The  Valid annotation will tell spring to go and validate the data passed into the controller by checking to see that the integer numberBetweenOneAndTen is between 1 and 10 inclusive because of those min and max annotations  It ll also check to make sure the ip address passed in matches the regular expression in the annotation  side note  the regular expression isn t perfect   you could pass in 3 digit numbers that are greater than 255 and it would still match the regular expression   Here s an example of validating a query variable and path variable   RestController  Validated class ValidateParametersController       GetMapping  quot  validatePathVariable  id  quot     ResponseEntity lt String gt  validatePathVariable         PathVariable  quot id quot    Min 5  int id        return ResponseEntity ok  quot valid quot              GetMapping  quot  validateRequestParameter quot     ResponseEntity lt String gt  validateRequestParameter         RequestParam  quot param quot    Min 5  int param         return ResponseEntity ok  quot valid quot           In this case  since the query variable and path variable are just integers instead of just complex classes  we put the constraint annotation  Min 5  right on the parameter instead of using  Valid

User · Answer

Another handy aspect of  Valid not mentioned above is that  ie  using Postman to test an endpoint   Valid will format the output of an incorrect REST call into formatted JSON instead of a blob of barely readable text  This is very useful if you are creating a commercially consumable API for your users

User · Answer

public String create  Valid  NotNull ScriptFile scriptFile  BindingResult result  ModelMap modelMap            if  scriptFile    null  throw new IllegalArgumentException  A scriptFile is required              I guess this  NotNull annotation is valid therefore if condition is not needed

[java] What does the @Valid annotation indicate in Spring?

Examples related to java

Examples related to spring

Examples related to spring-mvc

Examples related to spring-annotations