javax.validation.UnexpectedTypeException#org.springframework.validation.ObjectError源码实例Demo

@Test
public void multipleBuilderErrors() {
  ObjectError objectError1 = new ObjectError("errorOne", "Description one");
  ObjectError objectError2 = new ObjectError("errorTwo", "Description two");

  List<ObjectError> objectErrors = Arrays.asList(objectError1, objectError2);

  when(errors.getErrorCount()).thenReturn(objectErrors.size());
  when(errors.getAllErrors()).thenReturn(objectErrors);

  ValidationError result = ValidationError.builder(errors).build();

  List<String> expected = Arrays.asList(objectError1.getDefaultMessage(), objectError2.getDefaultMessage());

  assertThat(result.getErrors(), is(expected));
  assertThat(result.getErrorMessage(), is("Validation failed: 2 error(s)"));
}
 

/**
 * Maps an exception to an error.
 * 
 * @param ex
 * @return
 */
public static ServiceError mapException(Throwable ex) {
	ServiceError error = null;

       if (ex instanceof ServiceException) {
       	ServiceException servEx = (ServiceException)ex;
       	
       	error = servEx.error;
       } else if (ex instanceof MethodArgumentNotValidException) {
       	MethodArgumentNotValidException validationEx = (MethodArgumentNotValidException)ex;
       	
       	List<String> errors = Lists.newArrayList();
       	
       	for (ObjectError objError : validationEx.getBindingResult().getAllErrors()) {
       		errors.add(objError.getObjectName() + ":" + objError.getCode() + ":" + objError.getDefaultMessage());
       	}
       	
       	error = new ServiceError(VALIDATION_ERROR_CODE, Joiner.on("|").join(errors));
       } else {
       	error = new ServiceError(UNKNOWN_ERROR_CODE, ex.getMessage());
       }
       
       return error;
}
 

@ResponseBody
@PostMapping(value = "/ucenter/share/share_update")
public DataVo editShare(@Valid Share share, BindingResult result){
    DataVo data = DataVo.failure("操作失败");
    if (share.getId() == null) {
        return DataVo.failure("内容id错误！");
    }
    Share shareinfo=shareService.findShareById(share.getId(),0);
    if (getUser().getUserId() != shareinfo.getUserId()) {
        return DataVo.failure("只能修改属于自己的分享内容！");
    }
    try {
        if (result.hasErrors()) {
            List<ObjectError> list = result.getAllErrors();
            for (ObjectError error : list) {
                return DataVo.failure(error.getDefaultMessage());
            }
            return null;
        }
        share.setUserId(getUser().getUserId());
        data = shareService.updateShareById(share);
    } catch (Exception e) {
        data = DataVo.failure(e.getMessage());
    }
    return data;
}
 

@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 testSpringValidationWithAutowiredValidator() {
	ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(
			LocalValidatorFactoryBean.class);
	LocalValidatorFactoryBean validator = ctx.getBean(LocalValidatorFactoryBean.class);

	ValidPerson person = new ValidPerson();
	person.expectsAutowiredValidator = true;
	person.setName("Juergen");
	person.getAddress().setStreet("Juergen's Street");
	BeanPropertyBindingResult result = new BeanPropertyBindingResult(person, "person");
	validator.validate(person, result);
	assertEquals(1, result.getErrorCount());
	ObjectError globalError = result.getGlobalError();
	List<String> errorCodes = Arrays.asList(globalError.getCodes());
	assertEquals(2, errorCodes.size());
	assertTrue(errorCodes.contains("NameAddressValid.person"));
	assertTrue(errorCodes.contains("NameAddressValid"));
	ctx.close();
}
 

private void buildProblemErrorConstraintViolation(
    ObjectError objectError, Error.Builder builder) {
  String detail = null;
  String detailCode = null;

  String[] codes = objectError.getCodes();
  if (codes != null) {
    for (String code : codes) {
      String message = contextMessageSource.getMessage(code, objectError.getArguments());
      if (message != null && !message.equals('#' + code + '#')) {
        detail = message;
        detailCode = code;
        break;
      }
    }
  }

  if (detail == null) {
    detail = objectError.getDefaultMessage();
    if (detail == null) {
      detail = contextMessageSource.getMessage("org.molgenis.web.exception.ObjectError.generic");
    }
  }
  builder.setDetail(detail);
  builder.setErrorCode(detailCode != null ? detailCode : objectError.getCode());
}
 

/**
 * Parameters check message format.
 * 
 * @param bindingResult checkResult
 * @return
 */
private String getParamValidFaildMessage(BindingResult bindingResult) {
    List<ObjectError> errorList = bindingResult.getAllErrors();
    log.info("errorList:{}", JsonUtils.toJSONString(errorList));
    if (errorList == null) {
        log.warn("onWarning:errorList is empty!");
        return null;
    }

    ObjectError objectError = errorList.get(0);
    if (objectError == null) {
        log.warn("onWarning:objectError is empty!");
        return null;
    }
    return objectError.getDefaultMessage();
}
 

@RequestMapping(method = RequestMethod.PUT)
@ResponseBody
public String update(@Validated TaskDefineEntity taskDefineEntity, BindingResult bindingResult, HttpServletResponse response, HttpServletRequest request) {
    if (bindingResult.hasErrors()) {
        for (ObjectError m : bindingResult.getAllErrors()) {
            response.setStatus(421);
            return Hret.error(421, m.getDefaultMessage(), null);
        }
    }

    RetMsg retMsg = taskDefineService.update(parse(request));
    if (!retMsg.checkCode()) {
        response.setStatus(retMsg.getCode());
        return Hret.error(retMsg);
    }
    return Hret.success(retMsg);
}
 

@PostMapping("/category_edit_save")
@ResponseBody
public DataVo editCategory(@Valid ShareCategory shareCategory, BindingResult result){
    DataVo data = DataVo.failure("操作失败");
    try {
        if (result.hasErrors()) {
            List<ObjectError> list = result.getAllErrors();
            for (ObjectError error : list) {
                return DataVo.failure(error.getDefaultMessage());
            }
            return null;
        }
        data = shareCategoryService.editShareCategory(shareCategory);
    } catch (Exception e) {
        data = DataVo.failure(e.getMessage());
    }
    return data;
}
 

@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mav, NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory) {
    Popups popups = initializePopups(mav.getDefaultModel(), nativeWebRequest.getNativeRequest(HttpServletRequest.class));

    for (BindingResult result : getBindingResult(mav)) {
        for (ObjectError error : result.getAllErrors()) {
            Message message = asMessage(error);

            if (error instanceof FieldError) {
                popups.field(((FieldError) error).getField(), message);
            } else {
                popups.alert(message);
            }
        }
    }

    return popups;
}
 

@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(code = HttpStatus.BAD_REQUEST)
public ResponseEntity<ErrorMessage> handleMethodArgumentNotValid(MethodArgumentNotValidException ex
) {
	List<FieldError> fieldErrors = ex.getBindingResult().getFieldErrors();
	List<ObjectError> globalErrors = ex.getBindingResult().getGlobalErrors();
	List<String> errors = new ArrayList<>(fieldErrors.size() + globalErrors.size());
	String error;
	for (FieldError fieldError : fieldErrors) {
		error = fieldError.getField() + ", " + fieldError.getDefaultMessage();
		errors.add(error);
	}
	for (ObjectError objectError : globalErrors) {
		error = objectError.getObjectName() + ", " + objectError.getDefaultMessage();
		errors.add(error);
	}
	ErrorMessage errorMessage = new ErrorMessage(errors);

	//Object result=ex.getBindingResult();//instead of above can allso pass the more detailed bindingResult
	return new ResponseEntity(errorMessage, HttpStatus.BAD_REQUEST);
}
 

@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(code = HttpStatus.BAD_REQUEST)
public ResponseEntity<ErrorMessage> handleMethodArgumentNotValid(MethodArgumentNotValidException ex
) {
	List<FieldError> fieldErrors = ex.getBindingResult().getFieldErrors();
	List<ObjectError> globalErrors = ex.getBindingResult().getGlobalErrors();
	List<String> errors = new ArrayList<>(fieldErrors.size() + globalErrors.size());
	String error;
	for (FieldError fieldError : fieldErrors) {
		error = fieldError.getField() + ", " + fieldError.getDefaultMessage();
		errors.add(error);
	}
	for (ObjectError objectError : globalErrors) {
		error = objectError.getObjectName() + ", " + objectError.getDefaultMessage();
		errors.add(error);
	}
	ErrorMessage errorMessage = new ErrorMessage(errors);

	//Object result=ex.getBindingResult();//instead of above can allso pass the more detailed bindingResult
	return new ResponseEntity(errorMessage, HttpStatus.BAD_REQUEST);
}
 

@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(code = HttpStatus.BAD_REQUEST)
public ResponseEntity<ErrorMessage> handleMethodArgumentNotValid(MethodArgumentNotValidException ex
) {
	List<FieldError> fieldErrors = ex.getBindingResult().getFieldErrors();
	List<ObjectError> globalErrors = ex.getBindingResult().getGlobalErrors();
	List<String> errors = new ArrayList<>(fieldErrors.size() + globalErrors.size());
	String error;
	for (FieldError fieldError : fieldErrors) {
		error = fieldError.getField() + ", " + fieldError.getDefaultMessage();
		errors.add(error);
	}
	for (ObjectError objectError : globalErrors) {
		error = objectError.getObjectName() + ", " + objectError.getDefaultMessage();
		errors.add(error);
	}
	ErrorMessage errorMessage = new ErrorMessage(errors);

	//Object result=ex.getBindingResult();//instead of above can allso pass the more detailed bindingResult
	return new ResponseEntity(errorMessage, HttpStatus.BAD_REQUEST);
}
 

@ExceptionHandler(BindException.class)
public ResponseEntity<String> handle(BindException ex) {
  BindingResult validationResult = ex.getBindingResult();
  List<ObjectError> errors = validationResult.getAllErrors();
  Formatter f = new Formatter();
  f.format("Validation errors: ");
  for (ObjectError err : errors) {
    f.format(" %s%n", err.getDefaultMessage());
  }

  logger.warn(f.toString(), ex);

  HttpHeaders responseHeaders = new HttpHeaders();
  responseHeaders.setContentType(MediaType.TEXT_PLAIN);
  return new ResponseEntity<>(f.toString(), responseHeaders, HttpStatus.BAD_REQUEST);
}
 

@Override
protected String getMessage(WebExchangeBindException ex) {
    List<ObjectError> errors = ex.getAllErrors();
    if (!errors.isEmpty()) {
        StringBuilder sb = new StringBuilder();
        Iterator<ObjectError> it = errors.iterator();
        while (it.hasNext()) {
            sb.append(it.next().getDefaultMessage());
            if (it.hasNext()) {
                sb.append(" ");
            }
        }
        return sb.toString();
    }
    return ex.getMessage();
}
 

/**
 * Atualiza os dados de um funcionário.
 * 
 * @param id
 * @param funcionarioDto
 * @param result
 * @return ResponseEntity<Response<FuncionarioDto>>
 * @throws NoSuchAlgorithmException
 */
@PutMapping(value = "/{id}")
public ResponseEntity<Response<FuncionarioDto>> atualizar(@PathVariable("id") Long id,
		@Valid @RequestBody FuncionarioDto funcionarioDto, BindingResult result) throws NoSuchAlgorithmException {
	log.info("Atualizando funcionário: {}", funcionarioDto.toString());
	Response<FuncionarioDto> response = new Response<FuncionarioDto>();

	Optional<Funcionario> funcionario = this.funcionarioService.buscarPorId(id);
	if (!funcionario.isPresent()) {
		result.addError(new ObjectError("funcionario", "Funcionário não encontrado."));
	}

	this.atualizarDadosFuncionario(funcionario.get(), funcionarioDto, result);

	if (result.hasErrors()) {
		log.error("Erro validando funcionário: {}", result.getAllErrors());
		result.getAllErrors().forEach(error -> response.getErrors().add(error.getDefaultMessage()));
		return ResponseEntity.badRequest().body(response);
	}

	this.funcionarioService.persistir(funcionario.get());
	response.setData(this.converterFuncionarioDto(funcionario.get()));

	return ResponseEntity.ok(response);
}
 

/**
 * 更新任务
 * @param job
 * @return
 */
@ResponseBody
@PostMapping(value = "/update_job")
public DataVo update(@Valid Job job, BindingResult result) {
    DataVo data = DataVo.failure("操作失败");
    try {
        if (result.hasErrors()) {
            List<ObjectError> list = result.getAllErrors();
            for (ObjectError error : list) {
                return DataVo.failure(error.getDefaultMessage());
            }
            return null;
        }
        data = jobService.updateJobById(job);
    } catch (Exception e) {
        data = DataVo.failure(e.getMessage());
        log.warn(e.getMessage());
    }
    return data;
}
 

private BaseMatcher<BindException> getMatcher(String message, String field) {
	return new BaseMatcher<BindException>() {

		@Override
		public void describeTo(Description description) {

		}

		@Override
		public boolean matches(Object item) {
			BindException ex = (BindException) ((Exception) item).getCause();
			ObjectError error = ex.getAllErrors().get(0);
			boolean messageMatches = message.equals(error.getDefaultMessage());
			if (field == null) {
				return messageMatches;
			}
			String fieldErrors = ((FieldError) error).getField();
			return messageMatches && fieldErrors.equals(field);
		}

	};
}
 

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

	ValidPerson person = new ValidPerson();
	person.setName("Juergen");
	person.getAddress().setStreet("Juergen's Street");
	BeanPropertyBindingResult result = new BeanPropertyBindingResult(person, "person");
	validator.validate(person, result);
	assertEquals(1, result.getErrorCount());
	ObjectError globalError = result.getGlobalError();
	List<String> errorCodes = Arrays.asList(globalError.getCodes());
	assertEquals(2, errorCodes.size());
	assertTrue(errorCodes.contains("NameAddressValid.person"));
	assertTrue(errorCodes.contains("NameAddressValid"));
}
 

private String buildErrorMessage() {
    final StringBuilder detailBuilder = new StringBuilder();

    for (final ObjectError error : errors.getAllErrors()) {
        if (error instanceof FieldError) {
            final String fieldName = CaseFormat.UPPER_CAMEL.
                    to(CaseFormat.LOWER_UNDERSCORE, ((FieldError) error).getField());

            detailBuilder.
                    append("Field \"").
                    append(fieldName).
                    append("\" ").
                    append(error.getDefaultMessage()).
                    append("\n");
        } else {
            detailBuilder.append(error.toString());
        }
    }

    return detailBuilder.toString();
}
 

@ResponseBody
@PostMapping(value = "/update_links")
public DataVo updateFriendLink(@Valid Links links, BindingResult result) {
	DataVo data = DataVo.failure("操作失败");
       try {
           if (result.hasErrors()) {
               List<ObjectError> list = result.getAllErrors();
               for (ObjectError error : list) {
                   return DataVo.failure(error.getDefaultMessage());
               }
               return null;
           }
           if (!NumberUtils.isNumber(links.getId().toString())) {
               return DataVo.failure("友情链接ID参数错误！");
           }
           links.setLinkName(links.getLinkName().trim());
           links.setLinkUrl(links.getLinkUrl().trim());
           data = linksService.updateLinksById(links);
       } catch (Exception e) {
           data = DataVo.failure(e.getMessage());
           log.warn(e.getMessage());
       }
	return data;
}
 

@Test
public void testTestNewConnectionFails() {
    DatabaseConfig newConfig = new DatabaseConfig();
    doAnswer((Answer) invocation -> {
        MapBindingResult errors = invocation.getArgument(1, MapBindingResult.class);
        errors.addError(new ObjectError("failed", ERROR_MESSAGE));
        return null;
    }).when(connectionValidator).validate(any(), any());

    String result = underTest.testConnection(newConfig);

    assertEquals(ERROR_MESSAGE, result);
    verify(connectionValidator).validate(eq(newConfig), any());
}
 

@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 create_InvalidPasswordLength() {
	final Model model = createNiceMock(Model.class);
	final UserForm User = new UserForm();
	final BindingResult errors = createNiceMock(BindingResult.class);
	final String username = "usename";
	final String password = "pas"; //invalid length password
	final String confirmPassword = password;
	List<ObjectError> errorList = new ArrayList<ObjectError>();

	User.setUsername(username);
	User.setPassword(password);
	User.setConfirmPassword(confirmPassword);

	errorList.add(new ObjectError("password.invalid.length", "Password must be atleast 4 characters long"));

	expect(errors.hasErrors()).andReturn(true).anyTimes();
	expect(errors.getAllErrors()).andReturn(errorList).anyTimes();
	replay(errors);
	replay(model);
	String result = newAccountController.create(User, errors, model, request, redirectAttributes);
	errorList = errors.getAllErrors();

	assertThat(errorList.size(), CoreMatchers.equalTo(1));
	assertThat(errorList.get(0).getDefaultMessage(), CoreMatchers.equalTo("Password must be atleast 4 characters long"));
	assertThat(result, CoreMatchers.equalTo(ViewNames.NEW_ACCOUNT));
}
 

/**
 * Add a binding error 
 * @param error error to add
 */
public void addError(ObjectError error) {
	if (errors == null)
		createBindingResult();
	
	errors.addError(error);
}
 

@Test
public void shouldHandleException_handles_WebExchangeBindException_as_expected() {
    // given
    BindingResult bindingResult = 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())
    );
    when(bindingResult.getAllErrors()).thenReturn(errorsList);

    WebExchangeBindException ex = new WebExchangeBindException(null, bindingResult);

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

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

@Test
public void createErrorSelfDeleteContainsErrorMessage() {
    MapBindingResult bindingResult = new MapBindingResult(new HashMap<Object, Object>(), "username");

    BindingResult bindingSelfDeleteError = UserValidator.createSelfDeleteUserError(bindingResult);

    assertEquals(1, bindingSelfDeleteError.getErrorCount());

    List<ObjectError> errors = bindingSelfDeleteError.getAllErrors();
    ObjectError error = errors.get(0);

    assertEquals(UserValidator.ERRCODE_SELF_DELETE, error.getCode());
    assertEquals("user.self.delete.error", error.getDefaultMessage());
}
 

private <T extends ObjectError> List<T> escapeObjectErrors(List<T> source) {
	List<T> escaped = new ArrayList<>(source.size());
	for (T objectError : source) {
		escaped.add(escapeObjectError(objectError));
	}
	return escaped;
}
 

/**
 * Converte um LancamentoDto para uma entidade Lancamento.
 * 
 * @param lancamentoDto
 * @param result
 * @return Lancamento
 * @throws ParseException 
 */
private Lancamento converterDtoParaLancamento(LancamentoDto lancamentoDto, BindingResult result) throws ParseException {
	Lancamento lancamento = new Lancamento();

	if (lancamentoDto.getId().isPresent()) {
		Optional<Lancamento> lanc = this.lancamentoService.buscarPorId(lancamentoDto.getId().get());
		if (lanc.isPresent()) {
			lancamento = lanc.get();
		} else {
			result.addError(new ObjectError("lancamento", "Lançamento não encontrado."));
		}
	} else {
		lancamento.setFuncionario(new Funcionario());
		lancamento.getFuncionario().setId(lancamentoDto.getFuncionarioId());
	}

	lancamento.setDescricao(lancamentoDto.getDescricao());
	lancamento.setLocalizacao(lancamentoDto.getLocalizacao());
	lancamento.setData(this.dateFormat.parse(lancamentoDto.getData()));

	if (EnumUtils.isValidEnum(TipoEnum.class, lancamentoDto.getTipo())) {
		lancamento.setTipo(TipoEnum.valueOf(lancamentoDto.getTipo()));
	} else {
		result.addError(new ObjectError("tipo", "Tipo inválido."));
	}

	return lancamento;
}
 

/**
 * 新增域
 */
@RequestMapping(method = RequestMethod.POST)
@ResponseBody
@ApiOperation(value = "新增域信息", notes = "添加新的域信息，新增的域默认授权给创建人")
@ApiImplicitParam(name = "domain_id", value = "域编码", required = true, dataType = "String")
public String add(@Validated SysDomainInfoAddParamVo paramVo,
                  BindingResult bindingResult,
                  HttpServletResponse response,
                  HttpServletRequest request) {
    if (bindingResult.hasErrors()) {
        for (ObjectError m : bindingResult.getAllErrors()) {
            response.setStatus(421);
            return Hret.error(421, m.getDefaultMessage(), null);
        }
    }

    DomainEntity domainEntity = validParam(paramVo);
    String userId = JwtService.getConnUser(request).getUserId();
    domainEntity.setDomain_modify_user(userId);
    domainEntity.setCreate_user_id(userId);

    RetMsg retMsg = domainService.add(domainEntity);

    if (retMsg.checkCode()) {
        return Hret.success(retMsg);
    }

    response.setStatus(retMsg.getCode());
    return Hret.error(retMsg);
}