Question

我有一个域类定义如下

@Data
@Entity
public class City {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private long cityID;

    @NotBlank(message = "City name is a required field")
    private String cityName;


}

当我在没有cityName的情况下发布到端点http://localhost:8080/cities时，我得到一个ConstraintViolationException但是当我向没有cityName的端点http://localhost:8080/cities/1发送PUT请求时，我得到以下异常而不是ConstraintViolationException。

{
  "timestamp": 1494510208982,
  "status": 500,
  "error": "Internal Server Error",
  "exception": "org.springframework.transaction.TransactionSystemException",
  "message": "Could not commit JPA transaction; nested exception is javax.persistence.RollbackException: Error while committing the transaction",
  "path": "/cities/1"
}

那么如何为PUT请求获取ConstraintViolationException异常？

注意：我正在使用Spring Data Rest，因此端点是由Spring生成的。没有自定义的休息控制器。

Answer 1

我认为Cepr0的测试适用于PUT和POST，因为当您为不存在的实体发送PUT请求时，Spring Data Rest会在后台使用create方法。我们假设没有id = 100的用户：呼叫＆＃39; PUT用户/ 100＆＃39;与调用＆＃39; POST用户/＆＃39;

相同

当您为现有实体发送PUT时，它将生成令人讨厌的TransactionSystemException。

我现在也在与数据休息异常处理斗争，并且存在很多不一致。

这是我当前的RestErrorAttributes类，它解决了我的大多数问题，但是在接下来的几天里我很有可能会喜欢其他人。：）

@Component
@Slf4j
public class RestErrorAttributes extends DefaultErrorAttributes implements MessageSourceAware {

private MessageSource messageSource;

@Override
public void setMessageSource(MessageSource messageSource) {
    this.messageSource = messageSource;
}

/** {@inheritDoc} */
@Override
public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes, boolean includeStackTrace) {

    final Map<String, Object> errorAttributes = super.getErrorAttributes(requestAttributes, includeStackTrace);
    // Translate default message by Locale
    String message = errorAttributes.get("message").toString();
    errorAttributes.put("message",
            messageSource.getMessage(message, null, message, LocaleContextHolder.getLocale()));
    // Extend default error message by field-errors
    addConstraintViolationDetails(errorAttributes, requestAttributes);
    return errorAttributes;
}

private void addConstraintViolationDetails(Map<String, Object> errorAttributes,
        RequestAttributes requestAttributes) {
    Throwable error = getError(requestAttributes);
    if (error instanceof ConstraintViolationException) {
        errorAttributes.put("errors",
                RestFieldError.getErrors(((ConstraintViolationException) error).getConstraintViolations()));
    }
    else if (error instanceof RepositoryConstraintViolationException) {
        errorAttributes.put("errors", RestFieldError
                .getErrors(((RepositoryConstraintViolationException) error).getErrors().getAllErrors()));
    }
}

/** {@inheritDoc} */
@Override
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,
        Exception ex) {

    try {
        Throwable cause = ex;
        while (cause instanceof Exception) {
            // Handle AccessDeniedException - It cannot be handled by
            // ExceptionHandler
            if (cause instanceof AccessDeniedException) {
                response.sendError(HttpStatus.FORBIDDEN.value(), cause.getMessage());
                super.resolveException(request, response, handler, (Exception) cause);
                return new ModelAndView();
            }
            // Handle exceptions from javax validations
            if (cause instanceof ConstraintViolationException) {
                response.sendError(HttpStatus.UNPROCESSABLE_ENTITY.value(), "validation.error");
                super.resolveException(request, response, handler, (Exception) cause);
                return new ModelAndView();
            }
            // Handle exceptions from REST validator classes
            if (cause instanceof RepositoryConstraintViolationException) {
                response.sendError(HttpStatus.UNPROCESSABLE_ENTITY.value(), "validation.error");
                super.resolveException(request, response, handler, (Exception) cause);
                return new ModelAndView();
            }
            cause = ((Exception) cause).getCause();
        }
    } catch (final Exception handlerException) {
        log.warn("Handling of [" + ex.getClass().getName() + "] resulted in Exception", handlerException);
    }
    return super.resolveException(request, response, handler, ex);
}

@Getter
@AllArgsConstructor
public static class RestFieldError {
    private String field;
    private String code;
    private String message;

    public static List<RestFieldError> getErrors(Set<ConstraintViolation<?>> constraintViolations) {
        return constraintViolations.stream().map(RestFieldError::of).collect(Collectors.toList());
    }

    public static List<RestFieldError> getErrors(List<ObjectError> errors) {
        return errors.stream().map(RestFieldError::of).collect(Collectors.toList());
    }

    private static RestFieldError of(ConstraintViolation<?> constraintViolation) {
        return new RestFieldError(constraintViolation.getPropertyPath().toString(),
                constraintViolation.getMessageTemplate(), constraintViolation.getMessage());

    }

    private static RestFieldError of(ObjectError error) {

        return new RestFieldError(error instanceof FieldError ? ((FieldError) error).getField() : null,
                error.getCode(), error.getDefaultMessage());

    }
}

}

Answer 2

为此，我的解决方法是设置一个异常处理程序来处理TransactionSystemException，展开异常并像常规ConstraintViolationException一样处理：

@ExceptionHandler(value = {TransactionSystemException.class})
public ResponseEntity handleTxException(TransactionSystemException ex) {
    Throwable t = ex.getCause();
    if (t.getCause() instanceof ConstraintViolationException) {
        return handleConstraintViolation((ConstraintViolationException) t.getCause(), null);
    } else {
        return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

@ExceptionHandler({ConstraintViolationException.class})
public ResponseEntity<Object> handleConstraintViolation(ConstraintViolationException ex,
          WebRequest request) {
    List<String> errors = new ArrayList<>();
    for (ConstraintViolation<?> violation : ex.getConstraintViolations()) {
        errors.add(violation.getRootBeanClass().getName() + " " + violation.getPropertyPath() + ": " + violation.getMessage());
    }

    return new ResponseEntity<>(errors, new HttpHeaders(), HttpStatus.CONFLICT);
}

Spring Data Rest - Bean验证不适用于PUT方法？

2 个答案: