Inconsistent Validation Exception Types in Spring Web REST Controllers when handling Lists and Single Entities

Question

I am currently struggling with seemingly inconsistent behavior when dealing with request body validation in Spring REST Controllers.

Validation of singular entities result in a MethodArgumentNotValidException. Validation of Collections of the same entity class result in a ConstraintViolationException. My understanding is that the MethodArgumentNotValidException is the expected result during handling of Spring REST controllers, while ConstraintViolationExceptions are expected when Bean validation is done by Hibernate or other frameworks. However, in this case both occur while validating @RequestBody annotated entities.

Is there an explanation for this inconsistency? Furthermore, can I unify application behavior in any way? Handling of two different exception types translating validation exceptions completely differently is not ideal.

Example:

Controller:

@Validated
@RestController
@Slf4j
public class TestController {

  @PostMapping(path = "/test-entities")
  public ResponseEntity<Void> saveTestEntity(@Valid @RequestBody List<TestEntity> testEntities) {
    log.info("Received: {}", testEntities);
    return ResponseEntity.noContent()
        .build();
  }

  @PostMapping(path = "/test-entity")
  public ResponseEntity<Void> saveTestEntity(@Valid @RequestBody TestEntity testEntity) {
    log.info("Received {}", testEntity);
    return ResponseEntity.noContent()
        .build();
  }

}

Test Entity:

@Data
public class TestEntity {
  @NotEmpty String foo;
}

Controller Advice:

@ControllerAdvice
public class TestControllerAdvice {

  @ExceptionHandler(Exception.class)
  ResponseEntity<String> handleException(Exception exception) {
    return ResponseEntity.badRequest()
        .body(exception.getClass().getSimpleName());
  }

}

Test of Described Behavior

@WebMvcTest(controllers = TestController.class)
class ValidationExceptionsIssueApplicationTests {

  @Autowired
  MockMvc mockMvc;

  String expectedException = MethodArgumentNotValidException.class.getSimpleName();

  @Test
  void assertThatNoExceptionIsReturned() throws Exception {
    mockMvc.perform(post("/test-entities")
            .contentType(MediaType.APPLICATION_JSON)
            .content("""
                [
                  {"foo": "bar"}
                ]
                """))
        .andExpect(status().isNoContent());
  }

  @Test
  void whenSingleEntityIsSent_thenMethodArgumentNotValidExceptionIsThrown() throws Exception {
    mockMvc.perform(post("/test-entity")
            .contentType(MediaType.APPLICATION_JSON)
            .content("""
                  {"foo": ""}
                """))
        .andExpectAll(
            status().isBadRequest(),
            content().string(expectedException)
        );
  }

  @Test
  void whenArrayOfEntitiesAreSent_thenMethodArgumentNotValidExceptionIsThrown() throws Exception {
    mockMvc.perform(post("/test-entities")
            .contentType(MediaType.APPLICATION_JSON)
            .content("""
                [
                  {"foo": ""}
                ]
                """))
        .andExpectAll(
            status().isBadRequest(),
            content().string(expectedException) // <-- fails
        );
  }

}

Answer 1

There are 2 levels of validation here which first validate on the controller layer , then validate on the bean method.(See this for more details)

Both validations at the end delegate to Bean Validation to validate but calling different validation methods:

• In controller layer , it calls Validator#validate() and throw MethodArgumentNotValidException if fails
• In bean method layer , it calls ExecutableValidator#validateParameters() and throw ConstraintViolationException if fails.

For the entities list case, the problem is Bean Validation does not works for Validator#validate(List<TestEntity> testEntities) (p.s. not sure why but I guess it is not supported). So actually no validation happens on the controller layer and the validation finally take place on the bean method layer which throws ConstraintViolationException.

To make Validator#validate(List<TestEntity> testEntities) work , you can wrap the list into a wrapper object . Note that you also need to annotate @Valid in the List 's type argument :

public class TestEntityListWrapper {

    public List<@Valid TestEntity> entities = new ArrayList<>();

    public TestEntityListWrapper(){

    }

    @JsonCreator(mode = JsonCreator.Mode.DELEGATING)
    public TestEntityListWrapper(List<TestEntity> entities){
        this.entities = entities;
    }
}

@PostMapping(path = "/test-entities")
public ResponseEntity<Void> saveTestEntity(@Valid @RequestBody TestEntityListWrapper testEntities) {

}

Then it will throw MethodArgumentNotValidException for both case.

Or if you want both of them throw ConstraintViolationExceptions , you can refer to my answers at here to disable the Bean Validation in controller layer :

public class TestController{

    @InitBinder
    public void initBinder(WebDataBinder binder) {
        binder.setValidator(null);
   }

  @PostMapping(path = "/test-entities")
  public ResponseEntity<Void> saveTestEntity(@Valid @RequestBody List<TestEntity> testEntities) {

  }

}