For example, say we have a constraint that we should not allow more than 99 units of any product to be added if the unit price is greater than $ 1,000 for that product. Let's see how to add such a validation using Spring validation in our project:

In classic Spring validation, the main validation construct is the Validator (org.springframework.validation.Validator) interface. The Spring Validator interface defines two methods for validation purposes, namely supports and validate. The supports method indicates whether the validator can validate a specific class. If so, the validate method can be called to validate an object of that class.

Every Spring- based validator we are creating should implement this interface. In step 1 we just did just that; we simply created a class called UnitsInStockValidator, which implements the Spring Validator interface.

Inside the validate method of the UnitsInStockValidator class, we simply check whether the given Product object has a unit price greater than 1,000 and the number of units in stock is more than 99; if so, we reject that value with the corresponding error key to show the error message from the message source file:

@Override 
public void validate(Object target, Errors errors) { 
   Product product = (Product) target; 
 
   if(product.getUnitPrice()!= null && new BigDecimal(1000).compareTo(product.getUnitPrice())<=0 && product.getUnitsInStock()>99) { 
      errors.rejectValue("unitsInStock", "com.packt.webstore.validator.UnitsInStockValidator.message"); 
   } 
}  

In step 2 we simply added the actual error message for the error key com.packt.webstore.validator.UnitsInStockValidator.message in the message source file (messages.properties).

We created the validator but, to kick in the validation, we need to associate that validator with the controller. That's what we did in steps 3 and 4. In step 3 we simply added and autowired the reference to UnitsInStockValidator in the ProductController class. And we associated the unitsInStockValidator with WebDataBinder in the initialiseBinder method:

@InitBinder 
public void initialiseBinder(WebDataBinder binder) { 
 
   binder.setValidator(unitsInStockValidator);    
 
   binder.setAllowedFields("productId", 
         "name", 
         "unitPrice", 
         "description", 
         "manufacturer", 
         "category", 
         "unitsInStock", 
         "condition", 
         "productImage", 
         "language"); 
} 

That's it, we created and configured our Spring-based validator to do the validation. Now run our application and enter http://localhost:8080/webstore/market/products/add to show the web form for adding product info. Fill all the values in the form, particularly fill the Unit Price field with the value 1000 and Units in stock field with the value 150, and click on the Add button. You will see validation messages at the top of the form saying You cannot add more than 99 units if the unit price is greater than 1000.

It is good that we have added Spring-based validation into our application. But since we have configured our Spring-based validator (unitsInStockValidator) with WebDataBinder, the Bean Validation that we have configured earlier would not take effect. Spring MVC will simply ignore those JSR-303 Bean Validation annotations (@Pattern, @Size, @Min, @Digits, @NotNull, and more).

So we need to write those Bean Validations again in classic Spring-based validation. This is not a good idea but, thanks to the flexibility and extensibility of Spring validation, we can combine both Spring-based validation and Bean Validation together with a little extra code. Let's do that:

Well, our aim was to combine Bean Validations and our Spring-based validation (unitsInStockValidator) together, to create a common adapter validator called ProductValidator. If you notice closely, the ProductValidator class is nothing but an implementation of the regular Spring validator.

We have autowired our existing bean validator into the ProductValidator class through the following line:

@Autowired 
private javax.validation.Validator beanValidator; 

Later, we used this beanValidator reference inside the validate method of the ProductValidator class to validate all Bean Validation annotations, as follows:

Set<ConstraintViolation<Object>> constraintViolations = beanValidator.validate(target); 
       
for (ConstraintViolation<Object> constraintViolation : constraintViolations) { 
   String propertyPath = constraintViolation.getPropertyPath().toString(); 
   String message = constraintViolation.getMessage(); 
   errors.rejectValue(propertyPath, "", message); 
} 

The beanValidator.validate(target) statement returned all the constraint violations. Then, using the errors object, we threw all the invalid constraints as error messages. So every Bean Validation annotation we specified in the Product domain class will get handled within a for loop.

Similarly, we have one more for loop to handle all Spring validations in the validate method of the ProductValidator class:

for(Validator validator: springValidators) { 
   validator.validate(target, errors); 
} 

This for loop iterates through the set of Spring validators and validates them one by one, but if you notice, we haven't initiated the springValidators reference. Thus, you may wonder where we have initiated the springValidators set. You can find the answer in step 2; we have created a bean for the ProductValidator class in our web application context (WebApplicationContextConfig.java) and assigned the springValidators set:

   @Bean 
   public ProductValidator productValidator () { 
      Set<Validator> springValidators = new HashSet<>(); 
      springValidators.add(new UnitsInStockValidator()); 
 
      ProductValidator productValidator = new ProductValidator(); 
      productValidator.setSpringValidators(springValidators); 
 
      return productValidator; 
   } 

So now we have created a common adapter validator that can adopt Bean Validation and Spring validation, and validates all Spring and Bean-based validations together. Now we have to replace the UnitsInStockValidator reference with the ProductValidator reference in our ProductController class to kick in our new ProductValidator, which we have done in steps 3 and 4. We simply replaced the UnitsInStockValidator with ProductValidator in the binder, as follows:

@InitBinder 
public void initialiseBinder(WebDataBinder binder) { 
 
   binder.setValidator(productValidator);    
 
   binder.setAllowedFields("productId", 
         "name", 
         "unitPrice", 
         "description", 
         "manufacturer", 
         "category", 
         "unitsInStock", 
         "condition", 
         "productImage", 
         "language"); 
 
} 

So we have successfully configured our newly created ProductValidator with ProductController. To see it in action, just run our application and enter the URL http://localhost:8080/webstore/market/products/add. Then, enter some invalid values such as an existing product ID, or fill the Unit Price field with the value 1000 and the Units in stock field with the value 100. You will notice the Bean Validation error messages and Spring validation error messages on the screen.

Create a Spring validation class called ProductImageValidator, which will validate the size of the product image. It should only allow images whose size is less than or equal to the predefined configured size. Consider the following things while implementing your ProductImageValidator:

After applying your custom validation annotation @category on the category field of the Product domain class, your Add new product page should reject products of other categories that have been not configured in the CategoryValidator.