如何建议（AOP）spring webflux web 处理程序捕获和转换反应性错误

Question

[UPDATE 2021-10-11] 添加了 MCVE

https://github.com/SalathielGenese/issue-spring-webflux-reactive-error-advice

---

出于可重用性的考虑，我在服务层运行验证，返回Mono.error( constraintViolationException )...

这样我的 Web 处理程序只需将未编组的域转发到服务层。

到目前为止，非常棒。

---

但是我如何建议 (AOP) 我的 Web 处理程序，以便它返回带有格式化约束违规的 HTTP 422？

WebExchangeBindException 只处理同步抛出的异常（我不希望同步验证破坏响应式流程）。

我的 AOP 建议触发器和错误 b/c：

• 我的网络处理程序返回Mono<DataType>
• 但我的建议返回ResponseEntity

如果我将我的响应实体（来自建议）包装成一个Mono<ResponseEntity>，我是一个HTTP 200 OK，响应实体序列化:(

代码摘录

@Aspect
@Component
class CoreWebAspect {
    @Pointcut("withinApiCorePackage() && @annotation(org.springframework.web.bind.annotation.PostMapping)")
    public void postMappingWebHandler() {
    }

    @Pointcut("within(project.package.prefix.*)")
    public void withinApiCorePackage() {
    }

    @Around("postMappingWebHandler()")
    public Object aroundWebHandler(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        try {
            final var proceed = proceedingJoinPoint.proceed();

            if (proceed instanceof Mono<?> mono) {
                try {
                    return Mono.just(mono.toFuture().get());
                } catch (ExecutionException exception) {
                    if (exception.getCause() instanceof ConstraintViolationException constraintViolationException) {
                        return Mono.just(getResponseEntity(constraintViolationException));
                    }

                    throw exception.getCause();
                }
            }

            return proceed;
        } catch (ConstraintViolationException constraintViolationException) {
            return getResponseEntity(constraintViolationException);
        }
    }

    private ResponseEntity<Set<Violation>> getResponseEntity(final ConstraintViolationException constraintViolationException) {
        final var violations = constraintViolationException.getConstraintViolations().stream().map(violation -> new Violation(
                stream(violation.getPropertyPath().spliterator(), false).map(Node::getName).collect(toList()),
                violation.getMessageTemplate().replaceFirst("^\\{(.*)\\}$", "$1"))
        ).collect(Collectors.toSet());

        return status(UNPROCESSABLE_ENTITY).body(violations);
    }


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

Answer 1

根据观察（我在文档中没有找到任何证据），无论内容如何，​​响应时的Mono.just() 都会自动翻译成200 OK。因此，需要Mono.error()。但是，它的构造函数需要Throwable，所以ResponseStatusException 发挥作用。

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

• 请求：

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

• 响应（格式化）：

  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"
  }
  

终于，422 Unprocessable Entity被返回了！

遗憾的是，所需的 List<Violation> 作为正文只能作为 String reason 传递给 ResponseStatusException，这最终会得到一个丑陋的响应：

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

• 同样的请求
• 响应（格式化）：

  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"
  }
  

但是有一个解决方案定义ErrorAttributes bean 并将违规添加到正文中。从自定义异常开始，不要忘记使用@ResponseStatus(HttpStatus.UNPROCESSABLE_ENTITY) 对其进行注释以定义正确的响应状态代码：

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

    private final List<Violation> violations;
}

现在定义ErrorAttributes bean，获取违规并将其添加到正文中：

@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;
        }
    };
}

最后，在你的方面这样做：

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

并测试一下：

• 同样的请求
• 响应（格式化）：

  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"
        ]
      }
    ]
  }
  

测试会通过。不要忘记一些类是新的反应包：

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

Answer 2

用包含@ExceptionHandler 的@ControllerAdvice 替换方面怎么样？但是让我们清理主应用程序类，从中提取内部类到一个额外的类中：

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;
  }
}

现在你的测试都通过了。

顺便说一句，我不是 Spring 用户，我从 this answer 得到了这个想法。