Java BeanPropertyBindingResult.hasErrors方法代碼示例

import org.springframework.validation.BeanPropertyBindingResult; //導入方法依賴的package包/類
/**
 * Validate the payload if applicable.
 * <p>The default implementation checks for {@code @javax.validation.Valid},
 * Spring's {@link org.springframework.validation.annotation.Validated},
 * and custom annotations whose name starts with "Valid".
 * @param message the currently processed message
 * @param parameter the method parameter
 * @param target the target payload object
 * @throws MethodArgumentNotValidException in case of binding errors
 */
protected void validate(Message<?> message, MethodParameter parameter, Object target) {
	if (this.validator == null) {
		return;
	}
	for (Annotation ann : parameter.getParameterAnnotations()) {
		Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
		if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) {
			Object hints = (validatedAnn != null ? validatedAnn.value() : AnnotationUtils.getValue(ann));
			Object[] validationHints = (hints instanceof Object[] ? (Object[]) hints : new Object[] {hints});
			BeanPropertyBindingResult bindingResult =
					new BeanPropertyBindingResult(target, getParameterName(parameter));
			if (!ObjectUtils.isEmpty(validationHints) && this.validator instanceof SmartValidator) {
				((SmartValidator) this.validator).validate(target, bindingResult, validationHints);
			}
			else {
				this.validator.validate(target, bindingResult);
			}
			if (bindingResult.hasErrors()) {
				throw new MethodArgumentNotValidException(message, parameter, bindingResult);
			}
			break;
		}
	}
}
 

import org.springframework.validation.BeanPropertyBindingResult; //導入方法依賴的package包/類
/**
 * Deserializes the given message.
 * 
 * @param action
 * @return
 * @throws Exception
 */
public T deserialize(WebSocketAction action) throws Exception {
	// first deserialize
	T message = null;
	
	if (messageClass != null) {
		message = serDe.deserialize(new ByteBufferBackedInputStream(rawData), messageClass);
	}
	
	// then validate
	if (message != null && action.shouldValidatePayload()) {
		SpringValidatorAdapter validatorAdapter = new SpringValidatorAdapter(messageValidator);
		
		BeanPropertyBindingResult result = new BeanPropertyBindingResult(message, messageClass.getName());
		
		validatorAdapter.validate(message, result);
		
		if (result.hasErrors()) {
			throw new MethodArgumentNotValidException(new MethodParameter(action.getMethod(), action.getPayloadParameterIndex()), result);
		}
	}
	
	return message;
}
 

import org.springframework.validation.BeanPropertyBindingResult; //導入方法依賴的package包/類
/**
 * {@link RecordProcessor#run(String)}
 * @param inputFilePath
 * @throws DataImportException
 */
public void run(String inputFilePath) throws DataImportException {
	reader.doBefore(inputFilePath);
	writer.doBefore(this.getTempFilePath(inputFilePath));
	T record = reader.readRecord();
	while (record != null) {
		if (record instanceof DataSetAware) ((DataSetAware) record).setDataSetMetadata(dataSet);
		if (validator != null) {
			BeanPropertyBindingResult bindingResult
					= new BeanPropertyBindingResult(record, record.getClass().getName());
			validator.validate(record, bindingResult);
			if (bindingResult.hasErrors()){
				logger.warn(String.format("Record failed validation: %s", record.toString()));
				if (!options.isSkipInvalidRecords()){
					throw new DataImportException(bindingResult.toString());
				}
			}
		}
		writer.writeRecord(record);
		record = reader.readRecord();
	}
	writer.doAfter();
	reader.doAfter();
	if (importer != null) {
		importer.importFile(this.getTempFilePath(inputFilePath));
	}
}
 

import org.springframework.validation.BeanPropertyBindingResult; //導入方法依賴的package包/類
@Test
public void validationTest() throws Exception {
	EntrezGene gene = new EntrezGene();
	BeanPropertyBindingResult bindingResult = new BeanPropertyBindingResult(gene, gene.getClass().getName());
	validator.validate(gene, bindingResult);
	if (bindingResult.hasErrors()){
		for (ObjectError error: bindingResult.getAllErrors()){
			System.out.println(error.toString());
		}
	} else {
		fail("Validation did not catch missing field.");
	}
}
 

import org.springframework.validation.BeanPropertyBindingResult; //導入方法依賴的package包/類
protected void validate(Message<?> message, MethodParameter parameter,
		Object target) {
	if (this.validator == null) {
		return;
	}
	for (Annotation ann : parameter.getParameterAnnotations()) {
		Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class);
		if (validatedAnn != null
				|| ann.annotationType().getSimpleName().startsWith("Valid")) {
			Object hints = validatedAnn != null ? validatedAnn.value()
					: AnnotationUtils.getValue(ann);
			Object[] validationHints = hints instanceof Object[] ? (Object[]) hints
					: new Object[] { hints };
			BeanPropertyBindingResult bindingResult = new BeanPropertyBindingResult(
					target, getParameterName(parameter));
			if (!ObjectUtils.isEmpty(validationHints)
					&& this.validator instanceof SmartValidator) {
				((SmartValidator) this.validator).validate(target, bindingResult,
						validationHints);
			}
			else {
				this.validator.validate(target, bindingResult);
			}
			if (bindingResult.hasErrors()) {
				throw new MethodArgumentNotValidException(message, parameter,
						bindingResult);
			}
			break;
		}
	}
}
 

import org.springframework.validation.BeanPropertyBindingResult; //導入方法依賴的package包/類
@SuppressWarnings("unchecked")
public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
    Object result;
    try {

        //Check method that is being invoked actually even contains the Class we are interested in.
        if (args != null) {
            List<Object> parameterBeansToValidate = null;
            for (int i = 0; i < args.length; i++) {
                if (obj.getEntityClass().isAssignableFrom(args[i].getClass())) {
                    if (parameterBeansToValidate == null)
                        parameterBeansToValidate = new ArrayList<Object>();
                    parameterBeansToValidate.add(args[i]);
                }
            }

            if (parameterBeansToValidate != null && parameterBeansToValidate.size() > 0) {

                //Runs the validator against each bean that was in the parameters.
                for (Object paramBean : parameterBeansToValidate) {

                    if (cachedValidatorsMap.containsKey(paramBean.getClass())) {

                        List<Validator> validators = cachedValidatorsMap.get(paramBean.getClass());

                        for (Validator validator : validators) {
                            if (skip(validator))
                                continue;
                            List<ObjectError> validationErrors = null;
                            if (validator.supports(paramBean.getClass())) {
                                BeanPropertyBindingResult bindingResult = new BeanPropertyBindingResult
                                        (paramBean, paramBean.getClass().getName());
                                ValidationUtils.invokeValidator(validator, paramBean, bindingResult);

                                if (bindingResult.hasErrors()) {
                                    if (validationErrors == null)
                                        validationErrors = new ArrayList<ObjectError>();

                                    validationErrors.addAll(bindingResult.getAllErrors());
                                }
                            }

                            if (validationErrors != null && validationErrors.size() > 0) {
                                throw new BeanValidationException(paramBean.getClass().getName() + " " +
                                        "validation failed", validationErrors, paramBean);
                            }
                        }
                    } else {
                        logger.debug("No validators found for Bean - " + paramBean.getClass().getName());
                    }
                }
            }
        }

        logger.debug("Invoking method " + m.getName() + " from dynamic proxy " + getClass().getName());
        result = m.invoke(obj, args);

    } catch (InvocationTargetException e) {
        logger.error("problem with method " + m.getName(), e);
        throw e.getTargetException();
    } finally {
        logger.debug("after method " + m.getName());
    }
    return result;
}