下面列出了org.springframework.web.bind.annotation.ExceptionHandler#org.springframework.validation.FieldError 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* 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));
}