How to advise (AOP) spring webflux web handlers to catch and transform reactive error

From observation (I haven't found any proof in the documentation), Mono.just() on response is automatically translated into 200 OK regardless of the content. For that reason, Mono.error() is needed. However, its constructors require Throwable so ResponseStatusException comes into play.

return Mono.error(new ResponseStatusException(UNPROCESSABLE_ENTITY));

• Request:

  curl -i --request POST --url http://localhost:8080/welcome \
  --header 'Content-Type: application/json' \
  --data '{}'
  

• Response (formatted):

  HTTP/1.1 422 Unprocessable Entity
  Content-Type: application/json
  Content-Length: 147
  
  {
    "error": "Unprocessable Entity",
    "message": null,
    "path": "/welcome",
    "requestId": "7a3a464e-1",
    "status": 422,
    "timestamp": "2021-10-13T16:44:18.225+00:00"
  }
  

Finally, 422 Unprocessable Entity is returned!

Sadly, the required List<Violation> as a body can be passed into ResponseStatusException only as a String reason which ends up with an ugly response:

return Mono.error(new ResponseStatusException(UNPROCESSABLE_ENTITY, violations.toString()));

• Same request
• Response (formatted):

  HTTP/1.1 422 Unprocessable Entity
  Content-Type: application/json
  Content-Length: 300
  
  {
    "timestamp": "2021-10-13T16:55:30.927+00:00",
    "path": "/welcome",
    "status": 422,
    "error": "Unprocessable Entity",
    "message": "[IssueSpringWebfluxReactiveErrorAdviceApplication.AroundReactiveWebHandler.Violation(template={javax.validation.constraints.NotNull.message}, path=[name])]",
    "requestId": "de92dcbd-1"
  }
  

But there is a solution defining the ErrorAttributes bean and adding violations into the body. Start with a custom exception and don't forget to annotate it with @ResponseStatus(HttpStatus.UNPROCESSABLE_ENTITY) to define the correct response status code:

@Getter
@RequiredArgsConstructor
@ResponseStatus(HttpStatus.UNPROCESSABLE_ENTITY)
public class ViolationException extends RuntimeException {

    private final List<Violation> violations;
}

Now define the ErrorAttributes bean, get the violations and add it into the body:

@Bean
public ErrorAttributes errorAttributes() {
    return new DefaultErrorAttributes() {
        @Override
        public Map<String, Object> getErrorAttributes(ServerRequest request, ErrorAttributeOptions options) {
            Map<String, Object> errorAttributes = super.getErrorAttributes(request, options);
            Throwable error = getError(request);
            if (error instanceof ViolationException) {
                ViolationException violationException = (ViolationException) error;
                errorAttributes.put("violations", violationException .getViolations());
            }
            return errorAttributes;
        }
    };
}

And finally, do this in your aspect:

return Mono.error(new ViolationException(violations));

And test it out:

• Same request
• Response (formatted):

  HTTP/1.1 422 Unprocessable Entity
  Content-Type: application/json
  Content-Length: 238
  
  {
    "timestamp": "2021-10-13T17:07:07.668+00:00",
    "path": "/welcome",
    "status": 422,
    "error": "Unprocessable Entity",
    "message": "",
    "requestId": "a80b54d9-1",
    "violations": [
      {
        "template": "{javax.validation.constraints.NotNull.message}",
        "path": [
          "name"
        ]
      }
    ]
  }
  

The tests will pass. Don't forget some classes are newly from the reactive packages:

• org.springframework.boot.web.reactive.error.ErrorAttributes
• org.springframework.boot.web.reactive.error.DefaultErrorAttributes
• org.springframework.web.reactive.function.server.ServerRequest

How about replacing the aspect with a @ControllerAdvice containing an @ExceptionHandler? But let us clean up the main application class, extracting the inner classes from it into an extra class:

package name.genese.salathiel.issuespringwebfluxreactiveerroradvice;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

import static org.springframework.boot.SpringApplication.run;

@SpringBootApplication
@EnableAspectJAutoProxy
public class IssueSpringWebfluxReactiveErrorAdviceApplication {
  public static void main(String[] args) {
    run(IssueSpringWebfluxReactiveErrorAdviceApplication.class, args);
  }
}

package name.genese.salathiel.issuespringwebfluxreactiveerroradvice;

import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import javax.validation.ConstraintViolationException;
import javax.validation.Path;
import java.util.List;
import java.util.stream.Collectors;

import static java.util.stream.StreamSupport.stream;

@ControllerAdvice
public class ConstraintViolationExceptionHandler {
  @ExceptionHandler(ConstraintViolationException.class)
  public ResponseEntity<List<Violation>> handleException(ConstraintViolationException constraintViolationException) {
    final List<Violation> violations = constraintViolationException.getConstraintViolations().stream()
      .map(violation -> new Violation(
        violation.getMessageTemplate(),
        stream(violation.getPropertyPath().spliterator(), false)
          .map(Path.Node::getName)
          .collect(Collectors.toList())
      )).collect(Collectors.toList());

    return ResponseEntity.unprocessableEntity().body(violations);
  }

  @Getter
  @RequiredArgsConstructor
  static class Violation {
    private final String template;
    private final List<String> path;
  }
}

Now your tests both pass.

BTW, not being a Spring user, I got the idea from this answer.