It happened again: after writing about some issues caused by different JVM class-loader order a similar problem occured on Friday. One of my collagues (Dev-A) asked me to look into a problem the team had. Because of unknown reasons the Spring Boot based application did not return a serialized JSON error object after a @Valid annotated controller method parameter had been validated.

public class MyController { 
  // Validator for MyDto (MyDtoValidator) got called 
  public @ResponseBody MyData myMethod(@Valid MyDto myDto) { 
    return new MyData();

An @ControllerAdvice annotated class transformed any validation error into a new exception. This has been done to unify the validation errors when using Spring Data REST and Spring MVC validation.

public class ValidationErrorHandlerAdvice {
  private MessageSourceAccessor messageSourceAccessor;
  public ValidationErrorHandlerAdvice(MessageSourceAccessor messageSourceAccessor) {
    Assert.notNull(messageSourceAccessor, "messageSourceAccessor must not be null");
    this.messageSourceAccessor = messageSourceAccessor;
  @ExceptionHandler({ MethodArgumentNotValidException.class })
  public RepositoryConstraintViolationExceptionMessage handleValidationErrors(Locale locale, MethodArgumentNotValidException exception) {
    // this method should be called if the validation of MyController.myMethod had failed
    return produceException(exception.getBindingResult());
  @ExceptionHandler({ BindException.class })
  public RepositoryConstraintViolationExceptionMessage handleValidationErrors(Locale locale, BindException exception) {
    return produceException(exception.getBindingResult());
  private RepositoryConstraintViolationExceptionMessage produceException(BindingResult bindingResult) {
    return new RepositoryConstraintViolationExceptionMessage(new RepositoryConstraintViolationException(bindingResult), messageSourceAccessor);

All in all, the controller advice itself looked fine to me, especially as the code is easy to understand and has been used in other projects too without any problems.

Empty HTTP response body

Nevertheless the behavior was mysterious:

  • When calling /validated in the browser, the custom validator for MyDto so the controller method got definitely hit. Nevertheless none of the exception handlers in the ValidationErrorHandlerAdvice got called. To make it more mysterious the HTTP response Spring generated did only consist of the HTTP status code 400 (Bad Request) without any character in the HTTP response body. The response body was completely clear.
  • Another developer (Dev-B) uses Linux as operating system. On his machine the code above worked without any problems and returned the expected HTTP status code 400 with the serialized JSON validation error object.

Dev-A has a Windows based machine. When he had called the “/validated” endpoint on Dev-Bs host the repsonse body contained the serialized validation error. In return, when Dev-B (Linux) had called “/validated” on Dev-As machine (Windows) the response body was empty.
I checked the HTTP request headers of both browsers but they were more or less the same and did not have any influence on any HTTP pre-filters Spring had registered. Both environments uses the Oracle JDK with different update releases (u43 vs. u63). Patching both JDKs to the same level I wanted to try at last as it seemed unlikely to be the reason.

Debugging session

I started to debug through the Spring Framework and realized that the order in which the registered exception handlers got checked for their responsibility of the current occured exception was completely different. On Dev-Bs machine the ValidationErrorHandlerAdvice were the first in the list, on Dev-A the first responsible exception handler was located in ResponseEntityExceptionHandler.
After stepping further through ResponseEntityExceptionHandler it made absolutely sense that the response body was empty on Dev-As machine. But it does not made any sense that the ResponseEntityExceptionHandler got loaded in the first place.

After searching for more @ControllerAdvice annotated classes in the project I found this piece of code:

public class CustomErrorController extends ResponseEntityExceptionHandler { 
  public ModelAndView notFound(HttpServletRequest req, Exception exception) {; 
    ModelAndView mav = new ModelAndView(); 
    // ... not so important ... 
    return mav; 

Okay, at least the exception handler of ResponseEntityExceptionHandler was introduced without any Spring magic.

Fixing the problem

During debugging the initialization phase of Spring I saw that the order of the detected controller advices was different between both systems: CustomErrorController got registered before ValidationErrorHandlerAdvice on Dev-A and vice versa on Dev-B. As the wrong behavior only occured on Windows machines I assume that the underlying component scan is responsible for the different order.

In the end the fix for this solution was easy. I annotated both controllers with @Order and gave the ValidationErrorHandlerAdvice a higher precedence than CustomErrorController.

Recommended Reads

I’d like to recommend the following books which do a deep dive into Spring Framework/Spring Boot:

Categories: Java