CODEWITHSUNDEEP
javaspringhibernatevalidationspring-mvc
Ross Hettel
Ross Hettel

Reputation: 1129

Manually call Spring Annotation Validation

I'm doing a lot of our validation with Hibernate and Spring Annotations like so:

public class Account {
    @NotEmpty(groups = {Step1.class, Step2.class})
    private String name;

    @NotNull(groups = {Step2.class})
    private Long accountNumber;

    public interface Step1{}
    public interface Step2{}
}

And then in the controller it's called in the arguments:

public String saveAccount(@ModelAttribute @Validated({Account.Step1.class}) Account account, BindingResult result) {
   //some more code and stuff here
   return "";
}

But I would like to decide the group used based on some logic in the controller method. Is there a way to call validation manually? Something like result = account.validate(Account.Step1.class)?

I am aware of creating your own Validator class, but that's something I want to avoid, I would prefer to just use the annotations on the class variables themselves.

Upvotes: 78

Views: 91272

Answers (7)

Jaiwo99
Jaiwo99

Reputation: 10017

If you have everything correctly configured, you can do this:

import javax.validation.Validator;

@Autowired
Validator validator;

Then you can use it to validate you object:

var errors = validator.validate(obj);

Upvotes: 23

Pavel Horal
Pavel Horal

Reputation: 18194

Spring provides LocalValidatorFactoryBean, which implements the Spring SmartValidator interface as well as the Java Bean Validation Validator interface.

// org.springframework.validation.SmartValidator - implemented by LocalValidatorFactoryBean
@Autowired
SmartValidator validator;

public String saveAccount(@ModelAttribute Account account, BindingResult result) {
    // ... custom logic
    validator.validate(account, result, Account.Step1.class);
    if (result.hasErrors()) {
        // ... on binding or validation errors
    } else {
        // ... on no errors
    }
    return "";
}

Upvotes: 75

Shibin Francis
Shibin Francis

Reputation: 542

import javax.validation.Validator;
import javax.validation.ConstraintViolation;

public class{
    @Autowired
    private Validator validator;
       .
       .
    public void validateEmployee(Employee employee){

        Set<ConstraintViolation<Employee>> violations = validator.validate(employee);
        if(!violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }
    }
}

Here, 'Employee' is a pojo class and 'employee' is it's object

Upvotes: 1

Sarvar Nishonboyev
Sarvar Nishonboyev

Reputation: 13090

This link gives pretty good examples of using validations in Spring apps. https://reflectoring.io/bean-validation-with-spring-boot/

I have found an example to run the validation programmitically in this article. 

class MyValidatingService {

  void validatePerson(Person person) {
    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    Validator validator = factory.getValidator();
    Set<ConstraintViolation<Person>> violations = validator.validate(person);
    if (!violations.isEmpty()) {
      throw new ConstraintViolationException(violations);
    }
  } 
}

It throws 500 status, so it is recommended to handle it with custom exception handler. 

@ControllerAdvice(annotations = RestController.class)
public class CustomGlobalExceptionHandler extends ResponseEntityExceptionHandler {
    @ExceptionHandler(ConstraintViolationException.class)
    public ResponseEntity<CustomErrorResponse> constraintViolationException(HttpServletResponse response, Exception ex) throws IOException {
        CustomErrorResponse errorResponse = new CustomErrorResponse();
        errorResponse.setTimestamp(LocalDateTime.now());
        errorResponse.setStatus(HttpStatus.BAD_REQUEST.value());
        errorResponse.setError(HttpStatus.BAD_REQUEST.getReasonPhrase());
        errorResponse.setMessage(ex.getMessage());
        return new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);
    }
}

Second example is from https://www.mkyong.com/spring-boot/spring-rest-error-handling-example/

Update: Using validation is persistence layer is not recommended: https://twitter.com/odrotbohm/status/1055015506326052865

Upvotes: 12

Prabjot Singh
Prabjot Singh

Reputation: 4767

Adding to answered by @digitaljoel, you can throw the ConstraintViolationException once you got the set of violations.

Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
        Set<ConstraintViolation<NotionalProviderPaymentDTO>> violations = validator.validate( notionalProviderPaymentDTO );

        if(!violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }

You can create your own exception mapper which will handle ConstraintViolationException and send the errors messages to the client.

Upvotes: 8

supercobra
supercobra

Reputation: 16272

And also:

@Autowired
@Qualifier("mvcValidator")
Validator validator;

...
violations = validator.validate(account);

Upvotes: 1

digitaljoel
digitaljoel

Reputation: 26574

Here is a code sample from JSR 303 spec

Validator validator = Validation.buildDefaultValidatorFactory().getValidator();

Driver driver = new Driver();
driver.setAge(16);
Car porsche = new Car();
driver.setCar(porsche);


Set<ConstraintViolation<Driver>> violations = validator.validate( driver );

So yes, you can just get a validator instance from the validator factory and run the validation yourself, then check to see if there are violations or not. You can see in the javadoc for Validator that it will also accept an array of groups to validate against.

Obviously this uses JSR-303 validation directly instead of going through Spring validation, but I believe spring validation annotations will use JSR-303 if it's found in the classpath

Upvotes: 51

Related Questions