org.springframework.validation.FieldError Java Examples

/**
 * JSR303参数校验错误
 * @param ex BindException
 */
@ExceptionHandler({BindException.class,MethodArgumentNotValidException.class})
public JsonData<Void> bindException(MethodArgumentNotValidException ex) {
	LogBack.error(ex.getMessage(), ex);
	BindingResult bindingResult = ex.getBindingResult();
	if (bindingResult.hasErrors()) {
		List<FieldError> errors = bindingResult.getFieldErrors();
		List<ValidFieldError> validList = new ArrayList<>();
		if (!(CollectionUtils.isEmpty(errors))) {
			for (FieldError fe : errors) {
				validList.add(new ValidFieldError(fe));
			}
		}
		LogBack.error("参数校验错误：" + validList.toString(), ex);
		return JsonData.failed(StatusEnum.PARAM_INVALID, validList.toString());
	}
	return JsonData.failed(StatusEnum.PARAM_INVALID);
}
 

private Object exeute(HttpServletRequest reqest, HttpServletResponse response, Exception e) {
    log.error(StringUtil.getMessage(e), e);
    //if (isAjax(reqest)) {
    String exMsg = StringUtil.getMessage(e);
    if (e instanceof InvocationTargetException && exMsg == null) {
        exMsg = ((InvocationTargetException) e).getTargetException().getMessage();
    } else if (e instanceof MethodArgumentNotValidException) {
        List<String> list = StringUtil.toList(exMsg, "default message");
        if (CollectionUtils.isNotEmpty(list) && list.size() > 1) {
            List<FieldError> errors = ((MethodArgumentNotValidException) e).getBindingResult().getFieldErrors();
            if (CollectionUtils.isNotEmpty(list)) {
                exMsg = errors.get(0).getDefaultMessage();
            }
        }
    }
    if (exMsg == null) {
        exMsg = e.toString();
    }
    return ServiceResult.fail(exMsg);
   /* } else {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/err/500/index.html");
        return modelAndView;
    }*/
}
 

/**
 * 校验model上的注解
 *
 * @param pjp 连接点
 */
public static void checkModel(ProceedingJoinPoint pjp) {
    StringBuilder sb = new StringBuilder();
    try {
        //找到BindingResult参数
        List<BindingResult> results = getBindingResult(pjp);
        if (results != null && !results.isEmpty()) {
            for (BindingResult result : results) {
                if (null != result && result.hasErrors()) {
                    //拼接错误信息
                    if (null != result.getFieldErrors()) {
                        for (FieldError fe : result.getFieldErrors()) {
                            sb.append(fe.getField() + "-" + fe.getDefaultMessage()).append(" ");
                        }
                    }
                }
            }

            if (StringUtils.isNotBlank(sb.toString())) {
                fail(sb.toString());//抛出检查异常
            }
        }
    } catch (Exception e) {
        fail(e.getMessage());//抛出检查异常
    }
}
 

@Around("BindingResult()")
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
    Object[] args = joinPoint.getArgs();
    for (Object arg : args) {
        if (arg instanceof BindingResult) {
            BindingResult result = (BindingResult) arg;
            if (result.hasErrors()) {
                FieldError fieldError = result.getFieldError();
                if (fieldError != null) {
                    return CommonResult.validateFailed(fieldError.getDefaultMessage());
                } else {
                    return CommonResult.validateFailed();
                }
            }
        }
    }
    return joinPoint.proceed();
}
 

@Test  // SPR-13406
public void testApplyMessageSourceResolvableToStringArgumentValueWithResolvedLogicalFieldName() {
	TestBean testBean = new TestBean();
	testBean.setPassword("password");
	testBean.setConfirmPassword("PASSWORD");

	BeanPropertyBindingResult errors = new BeanPropertyBindingResult(testBean, "testBean");
	validatorAdapter.validate(testBean, errors);

	assertThat(errors.getFieldErrorCount("password"), is(1));
	assertThat(errors.getFieldValue("password"), is("password"));
	FieldError error = errors.getFieldError("password");
	assertNotNull(error);
	assertThat(messageSource.getMessage(error, Locale.ENGLISH), is("Password must be same value as Password(Confirm)"));
	assertTrue(error.contains(ConstraintViolation.class));
	assertThat(error.unwrap(ConstraintViolation.class).getPropertyPath().toString(), is("password"));
}
 

/**
 * Handle validation errors
 *
 * @return validation error with the fields errors and a bad request
 */
@ResponseStatus(value = HttpStatus.BAD_REQUEST)
@ExceptionHandler(value = MethodArgumentNotValidException.class)
@ResponseBody
public RestFieldsErrorsDto handleValidationExceptions(MethodArgumentNotValidException exception) {
  BindingResult result = exception.getBindingResult();

  String errorCode = RestErrorConstants.ERR_VALIDATION_ERROR;
  LOGGER.error(ERROR_MSG, errorCode, exception);

  RestFieldsErrorsDto restFieldsErrors = new RestFieldsErrorsDto(errorCode, getLocalizedMessageFromErrorCode(errorCode));

  List<FieldError> fieldErrors = result.getFieldErrors();
  fieldErrors.forEach(fieldError ->
      restFieldsErrors.addError(new RestFieldErrorDto(fieldError.getField(), fieldError.getCode(),
          getLocalizedMessageFromFieldError(fieldError))));

  return restFieldsErrors;

}
 

/**
 * @param bindingResult bindingResult
 * @return bindingResult错误内容
 */
public static String resolveErrorMessage(BindingResult bindingResult) {
    if (bindingResult == null || CollectionUtils.isEmpty(bindingResult.getFieldErrors())) {
        return "";
    }
    StringBuilder errorMsg = new StringBuilder();
    List<FieldError> fieldErrorList = bindingResult.getFieldErrors();
    for (FieldError fieldError : fieldErrorList) {
        errorMsg.append("[")
                .append(fieldError.getField())
                .append(":")
                .append(fieldError.getDefaultMessage())
                .append("]");
    }
    return errorMsg.toString();
}
 

@SuppressWarnings("unchecked")
@Nullable
private <T extends ObjectError> T escapeObjectError(@Nullable T source) {
	if (source == null) {
		return null;
	}
	String defaultMessage = source.getDefaultMessage();
	if (defaultMessage != null) {
		defaultMessage = HtmlUtils.htmlEscape(defaultMessage);
	}
	if (source instanceof FieldError) {
		FieldError fieldError = (FieldError) source;
		Object value = fieldError.getRejectedValue();
		if (value instanceof String) {
			value = HtmlUtils.htmlEscape((String) value);
		}
		return (T) new FieldError(
				fieldError.getObjectName(), fieldError.getField(), value, fieldError.isBindingFailure(),
				fieldError.getCodes(), fieldError.getArguments(), defaultMessage);
	}
	else {
		return (T) new ObjectError(
				source.getObjectName(), source.getCodes(), source.getArguments(), defaultMessage);
	}
}
 

@Test
public void testSpringValidationWithErrorInSetElement() {
	LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
	validator.afterPropertiesSet();

	ValidPerson person = new ValidPerson();
	person.getAddressSet().add(new ValidAddress());
	BeanPropertyBindingResult result = new BeanPropertyBindingResult(person, "person");
	validator.validate(person, result);
	assertEquals(3, result.getErrorCount());
	FieldError fieldError = result.getFieldError("name");
	assertEquals("name", fieldError.getField());
	fieldError = result.getFieldError("address.street");
	assertEquals("address.street", fieldError.getField());
	fieldError = result.getFieldError("addressSet[].street");
	assertEquals("addressSet[].street", fieldError.getField());
}
 

@Test  // SPR-13406
public void testNoStringArgumentValue() {
	TestBean testBean = new TestBean();
	testBean.setPassword("pass");
	testBean.setConfirmPassword("pass");

	BeanPropertyBindingResult errors = new BeanPropertyBindingResult(testBean, "testBean");
	validatorAdapter.validate(testBean, errors);

	assertThat(errors.getFieldErrorCount("password"), is(1));
	assertThat(errors.getFieldValue("password"), is("pass"));
	FieldError error = errors.getFieldError("password");
	assertNotNull(error);
	assertThat(messageSource.getMessage(error, Locale.ENGLISH), is("Size of Password is must be between 8 and 128"));
	assertTrue(error.contains(ConstraintViolation.class));
	assertThat(error.unwrap(ConstraintViolation.class).getPropertyPath().toString(), is("password"));
}
 

/**
 * The handleMethodArgumentNotValid method creates a response with a list of messages that contains the fields with errors
 *
 * @param exception MethodArgumentNotValidException
 * @return 400 and a list of messages with invalid fields
 */
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<ApiMessageView> handleMethodArgumentNotValid(MethodArgumentNotValidException exception) {
    List<FieldError> fieldErrors = exception.getBindingResult().getFieldErrors();
    List<Object[]> messages = new ArrayList<>();

    for (FieldError fieldError : fieldErrors) {
        Object[] messageFields = new Object[3];
        messageFields[0] = fieldError.getField();
        messageFields[1] = fieldError.getRejectedValue();
        messageFields[2] = fieldError.getDefaultMessage();
        messages.add(messageFields);
    }

    List<ApiMessage> listApiMessage = messageService
        .createMessage("org.zowe.apiml.sampleservice.api.petMethodArgumentNotValid", messages)
        .stream()
        .map(Message::mapToApiMessage)
        .collect(Collectors.toList());

    return ResponseEntity
        .status(HttpStatus.BAD_REQUEST)
        .contentType(MediaType.APPLICATION_JSON_UTF8)
        .body(new ApiMessageView(listApiMessage));
}
 

/**
 * <p>返回失败,无数据</p>
 * @param BindingResult
 * @return JsonResult
 */
public JsonResult<T> error(BindingResult result, MessageSource messageSource) {
    StringBuffer msg = new StringBuffer();
    // 获取错位字段集合
    List<FieldError> fieldErrors = result.getFieldErrors();
    // 获取本地locale,zh_CN
    Locale currentLocale = LocaleContextHolder.getLocale();
    for (FieldError fieldError : fieldErrors) {
        // 获取错误信息
        String errorMessage = messageSource.getMessage(fieldError, currentLocale);
        // 添加到错误消息集合内
        msg.append(fieldError.getField() + "：" + errorMessage + " ");
    }
    this.setCode(CODE_FAILED);
    this.setMsg(msg.toString());
    this.setData(null);
    return this;
}
 

@Test  // SPR-13406
public void testNoStringArgumentValue() {
	TestBean testBean = new TestBean();
	testBean.setPassword("pass");
	testBean.setConfirmPassword("pass");

	BeanPropertyBindingResult errors = new BeanPropertyBindingResult(testBean, "testBean");
	validatorAdapter.validate(testBean, errors);

	assertThat(errors.getFieldErrorCount("password"), is(1));
	assertThat(errors.getFieldValue("password"), is("pass"));
	FieldError error = errors.getFieldError("password");
	assertNotNull(error);
	assertThat(messageSource.getMessage(error, Locale.ENGLISH), is("Size of Password is must be between 8 and 128"));
	assertTrue(error.contains(ConstraintViolation.class));
	assertThat(error.unwrap(ConstraintViolation.class).getPropertyPath().toString(), is("password"));
}
 

@Test
public void testSpringValidationWithErrorInSetElement() {
	LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
	validator.afterPropertiesSet();

	ValidPerson person = new ValidPerson();
	person.getAddressSet().add(new ValidAddress());
	BeanPropertyBindingResult result = new BeanPropertyBindingResult(person, "person");
	validator.validate(person, result);
	assertEquals(3, result.getErrorCount());
	FieldError fieldError = result.getFieldError("name");
	assertEquals("name", fieldError.getField());
	fieldError = result.getFieldError("address.street");
	assertEquals("address.street", fieldError.getField());
	fieldError = result.getFieldError("addressSet[].street");
	assertEquals("addressSet[].street", fieldError.getField());
}
 

public String getFieldErrorMessage(FieldError fe, boolean readFieldMeta){
		if(fe==null){
//			throw new JFishException("can not find this field named : " + fieldName);
			return "";
		}

		String fmsg = null;
		if(readFieldMeta){
			JFishProperty jp = JFishPropertyFactory.create(getTarget().getClass(), fe.getField(), true);
			if(jp==null)
				jp = JFishPropertyFactory.create(getTarget().getClass(), fe.getField(), false);
			FieldName jfm = jp.getAnnotation(FieldName.class);
			if(jfm==null){
				fmsg = LangUtils.append(fe.getField(), fe.getDefaultMessage());
			}else{
				fmsg = LangUtils.append(jfm.value(), fe.getDefaultMessage());
			}
		}else{
			fmsg = fe.getDefaultMessage();
		}
		return fmsg;
	}
 

/**
 * IllegalArgumentException异常处理返回json
 * 返回状态码:500
 */
@ResponseStatus(HttpStatus.OK)
@ExceptionHandler({MethodArgumentNotValidException.class})
public JSONResult argumentNotValidException(MethodArgumentNotValidException e) {
    List<FieldError> bindingResult = e.getBindingResult().getFieldErrors();
    StringBuilder sb = new StringBuilder();
    //请求参数错误
    sb.append(ErrorEnum.ERROR_PARAM.getErrorMessage()).append(" --> ");
    for (FieldError fieldError : bindingResult) {
        sb.append(fieldError.getField());
        sb.append(" : ");
        sb.append(fieldError.getDefaultMessage());
        sb.append(" ; ");
    }

    return defHandler(null, sb.toString(), e);
}
 

@Test
public void testSpringValidation() throws Exception {
	LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
	validator.afterPropertiesSet();
	ValidPerson person = new ValidPerson();
	BeanPropertyBindingResult result = new BeanPropertyBindingResult(person, "person");
	validator.validate(person, result);
	assertEquals(2, result.getErrorCount());
	FieldError fieldError = result.getFieldError("name");
	assertEquals("name", fieldError.getField());
	List<String> errorCodes = Arrays.asList(fieldError.getCodes());
	assertEquals(4, errorCodes.size());
	assertTrue(errorCodes.contains("NotNull.person.name"));
	assertTrue(errorCodes.contains("NotNull.name"));
	assertTrue(errorCodes.contains("NotNull.java.lang.String"));
	assertTrue(errorCodes.contains("NotNull"));
	fieldError = result.getFieldError("address.street");
	assertEquals("address.street", fieldError.getField());
	errorCodes = Arrays.asList(fieldError.getCodes());
	assertEquals(5, errorCodes.size());
	assertTrue(errorCodes.contains("NotNull.person.address.street"));
	assertTrue(errorCodes.contains("NotNull.address.street"));
	assertTrue(errorCodes.contains("NotNull.street"));
	assertTrue(errorCodes.contains("NotNull.java.lang.String"));
	assertTrue(errorCodes.contains("NotNull"));
}
 

private ApiResourcePropertyError toResourcePropertyError(FieldError fieldError) {

        return ApiResourcePropertyError.builder()
                .property(fieldError.getField())
                .message(fieldError.getDefaultMessage())
                .invalidValue(fieldError.getRejectedValue())
                .build();
    }
 

public static Problem invalidProblem(final String field, final String description) {
    final FieldError[] fieldErrors = {new FieldError("", field, description)};

    final Errors errors = mock(Errors.class);
    when(errors.getAllErrors()).thenReturn(Arrays.asList(fieldErrors));
    return new ValidationProblem(errors);
}
 

private ObjectError convertError(ConfigurationPropertyName name,
                                 Set<ConfigurationProperty> boundProperties, ObjectError error) {
    if (error instanceof FieldError) {
        return convertFieldError(name, boundProperties, (FieldError) error);
    }
    return error;
}
 

private ErrorVM processFieldErrors(List<FieldError> fieldErrors) {
    ErrorVM dto = new ErrorVM(ErrorConstants.ERR_VALIDATION);

    for (FieldError fieldError : fieldErrors) {
        dto.add(fieldError.getObjectName(), fieldError.getField(), fieldError.getCode());
    }

    return dto;
}
 

@Test
void shouldJoinAllErrorMessages() {
    // given
    var objectError = new ObjectError("stack", "mandatory variables should not be null");
    var fieldError = new FieldError("stack", "name", "should not be blank");
    when(bindingResult.getAllErrors()).thenReturn(List.of(objectError, fieldError));

    // when
    var result = handler.handleValidationExceptions(new MethodArgumentNotValidException(null, bindingResult));

    // then
    assertThat(result).containsEntry("message", "mandatory variables should not be null\nname should not be blank");
}
 

@Test
public void shouldHandleException_delegates_to_extractAllErrorsFromWebExchangeBindException_for_WebExchangeBindException_error_retrieval() {
    // given
    ConventionBasedSpringValidationErrorToApiErrorHandlerListener listenerSpy = spy(listener);

    WebExchangeBindException ex = new WebExchangeBindException(null, mock(BindingResult.class));

    ApiError someFieldError = testProjectApiErrors.getMissingExpectedContentApiError();
    ApiError otherFieldError = testProjectApiErrors.getTypeConversionApiError();
    ApiError notAFieldError = testProjectApiErrors.getGenericBadRequestApiError();
    List<ObjectError> errorsList = Arrays.asList(
        new FieldError("someObj", "someField", someFieldError.getName()),
        new FieldError("otherObj", "otherField", otherFieldError.getName()),
        new ObjectError("notAFieldObject", notAFieldError.getName())
    );

    doReturn(errorsList).when(listenerSpy).extractAllErrorsFromWebExchangeBindException(ex);

    // when
    ApiExceptionHandlerListenerResult result = listenerSpy.shouldHandleException(ex);

    // then
    validateResponse(result, true, Arrays.asList(
        new ApiErrorWithMetadata(someFieldError, Pair.of("field", "someField")),
        new ApiErrorWithMetadata(otherFieldError, Pair.of("field", "otherField")),
        notAFieldError
    ));
    verify(listenerSpy).extractAllErrorsFromWebExchangeBindException(ex);
}
 

@Test
public void testSpringValidation() throws Exception {
	LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
	validator.afterPropertiesSet();

	ValidPerson person = new ValidPerson();
	BeanPropertyBindingResult result = new BeanPropertyBindingResult(person, "person");
	validator.validate(person, result);
	assertEquals(2, result.getErrorCount());
	FieldError fieldError = result.getFieldError("name");
	assertEquals("name", fieldError.getField());
	List<String> errorCodes = Arrays.asList(fieldError.getCodes());
	assertEquals(4, errorCodes.size());
	assertTrue(errorCodes.contains("NotNull.person.name"));
	assertTrue(errorCodes.contains("NotNull.name"));
	assertTrue(errorCodes.contains("NotNull.java.lang.String"));
	assertTrue(errorCodes.contains("NotNull"));
	fieldError = result.getFieldError("address.street");
	assertEquals("address.street", fieldError.getField());
	errorCodes = Arrays.asList(fieldError.getCodes());
	assertEquals(5, errorCodes.size());
	assertTrue(errorCodes.contains("NotNull.person.address.street"));
	assertTrue(errorCodes.contains("NotNull.address.street"));
	assertTrue(errorCodes.contains("NotNull.street"));
	assertTrue(errorCodes.contains("NotNull.java.lang.String"));
	assertTrue(errorCodes.contains("NotNull"));
}
 

private ErrorDTO processFieldErrors(List<FieldError> fieldErrors) {
    ErrorDTO dto = new ErrorDTO(ErrorConstants.ERR_VALIDATION);

    for (FieldError fieldError : fieldErrors) {
        dto.add(fieldError.getObjectName(), fieldError.getField(), fieldError.getCode());
    }

    return dto;
}
 

/**
 * 对hibernate-validator异常错误信息简单处理
 * @param error
 * @return
 */
private Result getFieldErrorResult(FieldError error) {
	StringBuilder errorMsg = new StringBuilder(100);
	errorMsg.append("$(form).find(\"[name=\\\"");
	errorMsg.append(error.getField());
	errorMsg.append("\\\"]\").closest(\"td\").prev().text() + \"，");
	errorMsg.append(error.getDefaultMessage());
	errorMsg.append("\"");
	Result _result = new Result();
	_result.setMsg(errorMsg.toString());
	return _result;
}
 

/**
 * 添加全局异常处理流程
 *
 * @param e
 * @return
 * @throws Exception
 */
@ResponseBody
@ExceptionHandler(Exception.class)
public ResponseDTO exceptionHandler(Exception e) {
    log.error("error:", e);

    // http 请求方式错误
    if (e instanceof HttpRequestMethodNotSupportedException) {
        return ResponseDTO.wrap(ResponseCodeConst.REQUEST_METHOD_ERROR);
    }

    // 参数类型错误
    if (e instanceof TypeMismatchException) {
        return ResponseDTO.wrap(ResponseCodeConst.ERROR_PARAM);
    }

    // json 格式错误
    if (e instanceof HttpMessageNotReadableException) {
        return ResponseDTO.wrap(ResponseCodeConst.JSON_FORMAT_ERROR);
    }

    // 参数校验未通过
    if (e instanceof MethodArgumentNotValidException) {
        List<FieldError> fieldErrors = ((MethodArgumentNotValidException) e).getBindingResult().getFieldErrors();
        List<String> msgList = fieldErrors.stream().map(FieldError :: getDefaultMessage).collect(Collectors.toList());
        return ResponseDTO.wrap(ResponseCodeConst.ERROR_PARAM, String.join(",", msgList));
    }

    if (e instanceof SmartBusinessException) {
        return ResponseDTO.wrap(ResponseCodeConst.SYSTEM_ERROR);
    }

    return ResponseDTO.wrap(ResponseCodeConst.SYSTEM_ERROR);
}
 

@ExceptionHandler(MethodArgumentNotValidException.class)
public BaseResponse handleError(MethodArgumentNotValidException e) {
    logger.warn("Method Argument Not Valid", e);
    BindingResult result = e.getBindingResult();
    FieldError error = result.getFieldError();
    String message = String.format("%s:%s", error.getField(), error.getDefaultMessage());
    return BaseResponse
            .builder()
            .code(ResultCode.PARAM_VALID_ERROR)
            .message(message)
            .build();
}
 

@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ResponseBody
public ErrorDTO processValidationError(MethodArgumentNotValidException ex) {
    BindingResult result = ex.getBindingResult();
    List<FieldError> fieldErrors = result.getFieldErrors();

    return processFieldErrors(fieldErrors);
}
 

private void assertError(Errors errors, String field, String expectedCode) {
    assertTrue(errors.getErrorCount() > 0);

    FieldError fieldError = errors.getFieldError(field);
    assertNotNull("Error field must have been set", fieldError);

    assertTrue(String.format("Missing expected error code for field '%s'\nExpected: '%s', actual ones: %s",
            field, expectedCode, Arrays.toString(fieldError.getCodes())),
            Arrays.asList(fieldError.getCodes()).contains(expectedCode));
}