Java NotReadablePropertyException类代码示例

import org.springframework.beans.NotReadablePropertyException; //导入依赖的package包/类
@Override
protected void processConstraintViolations(Set<ConstraintViolation<Object>> violations, Errors errors) {
    for (ConstraintViolation<Object> violation : violations) {
        String field = violation.getPropertyPath().toString();
        FieldError fieldError = errors.getFieldError(field);
        if (fieldError == null || !fieldError.isBindingFailure()) {
            try {
                String errorCode = violation.getConstraintDescriptor().getAnnotation().annotationType().getSimpleName();
                Object[] errorArgs = getArgumentsForConstraint(errors.getObjectName(), field, violation.getConstraintDescriptor());
                // NOTE: Super implementation of getInvalidValue() failed on a nested component. 
                // E.g. LocalizedString.fi returned LocalizedString instead of String as invalidValue
                errors.rejectValue(field, errorCode, errorArgs, violation.getMessage());
            }
            catch (NotReadablePropertyException ex) {
                throw new IllegalStateException("JSR-303 validated property '" + field +
                        "' does not have a corresponding accessor for Spring data binding - " +
                        "check your DataBinder's configuration (bean property versus direct field access)", ex);
            }
        }
    }
}
 

import org.springframework.beans.NotReadablePropertyException; //导入依赖的package包/类
public void testGetValueModelFromPAS() {
	TestBean p = new TestBean();
	TestPropertyAccessStrategy tpas = new TestPropertyAccessStrategy(p);
	AbstractFormModel fm = getFormModel(tpas, true);
	ValueModel vm1 = fm.getValueModel("simpleProperty");
	assertEquals(1, tpas.numValueModelRequests());
	assertEquals("simpleProperty", tpas.lastRequestedValueModel());
	ValueModel vm2 = fm.getValueModel("simpleProperty");
	assertEquals(vm1, vm2);
	assertEquals(1, tpas.numValueModelRequests());

	try {
		fm.getValueModel("iDontExist");
		fail("should't be able to get value model for invalid property");
	}
	catch (NotReadablePropertyException e) {
		// exprected
	}
}
 

import org.springframework.beans.NotReadablePropertyException; //导入依赖的package包/类
protected NotReadablePropertyException createNotReadablePropertyException(String propertyName, Exception e) {
	if (JdkVersion.isAtLeastJava14()) {
		NotReadablePropertyException beanException = new NotReadablePropertyException(getTargetClass(),
				propertyName);
		beanException.initCause(e);
		return beanException;
	}
	else {
		ByteArrayOutputStream stackTrace = new ByteArrayOutputStream();
		PrintWriter stackTraceWriter = new PrintWriter(stackTrace);
		e.printStackTrace(stackTraceWriter);
		stackTraceWriter.close();
		return new NotReadablePropertyException(getTargetClass(), propertyName,
				new String(stackTrace.toByteArray()));
	}
}
 

import org.springframework.beans.NotReadablePropertyException; //导入依赖的package包/类
@Override
public Object getValue(String paramName) throws IllegalArgumentException {
	try {
		return this.beanWrapper.getPropertyValue(paramName);
	}
	catch (NotReadablePropertyException ex) {
		throw new IllegalArgumentException(ex.getMessage());
	}
}
 

import org.springframework.beans.NotReadablePropertyException; //导入依赖的package包/类
/**
 * Checks whether the given property is secure.
 *
 * @param wrappedClass class the property is associated with
 * @param propertyPath path to the property
 * @return boolean true if the property is secure, false if not
 */
protected boolean isSecure(Class<?> wrappedClass, String propertyPath) {
    if (KRADUtils.isSecure(propertyPath, wrappedClass)) {
        return true;
    }

    // since this is part of a set, we want to make sure nested paths grow
    setAutoGrowNestedPaths(true);

    BeanWrapperImpl beanWrapper;
    try {
        beanWrapper = getBeanWrapperForPropertyPath(propertyPath);
    } catch (NotReadablePropertyException | NullValueInNestedPathException e) {
        LOG.debug("Bean wrapper was not found for " + propertyPath
                + ", but since it cannot be accessed it will not be set as secure.", e);
        return false;
    }

    if (org.apache.commons.lang.StringUtils.isNotBlank(beanWrapper.getNestedPath())) {
        PropertyTokenHolder tokens = getPropertyNameTokens(propertyPath);
        String nestedPropertyPath = org.apache.commons.lang.StringUtils.removeStart(tokens.canonicalName,
                beanWrapper.getNestedPath());

        return isSecure(beanWrapper.getWrappedClass(), nestedPropertyPath);
    }

    return false;
}
 

import org.springframework.beans.NotReadablePropertyException; //导入依赖的package包/类
public Object getValue(String paramName) throws IllegalArgumentException {
	try {
		return this.beanWrapper.getPropertyValue(paramName);
	}
	catch (NotReadablePropertyException ex) {
		throw new IllegalArgumentException(ex.getMessage());
	}
}
 

import org.springframework.beans.NotReadablePropertyException; //导入依赖的package包/类
public void testWriteOnlyProperty() {
    vm = pas.getPropertyValueModel("writeOnly");

    vm.setValue("2");
    assertEquals("2" , testBean.writeOnly);

    try {
        vm.getValue();
        fail("should have thrown NotReadablePropertyException");
    } catch(NotReadablePropertyException e) {
        // expected
    }
}
 

import org.springframework.beans.NotReadablePropertyException; //导入依赖的package包/类
public Object getIndexedPropertyValue(String propertyName) throws BeansException {
	if (getPropertyType(propertyName) == null) {
		throw new NotReadablePropertyException(getTargetClass(), propertyName,
				"property type could not be determined");
	}
	String rootPropertyName = getRootPropertyName(propertyName);
	Member readAccessor = getReadPropertyAccessor(rootPropertyName);
	if (readAccessor == null) {
		throw new NotReadablePropertyException(getTargetClass(), propertyName,
				"Neither non-static field nor get-method exists for indexed property");
	}
	Object rootProperty = getPropertyValue(rootPropertyName);
	if (rootProperty == null) {
		if (isStrictNullHandlingEnabled()) {
			throw new NullValueInNestedPathException(getTargetClass(), propertyName);
		}
		else if (isWritableProperty(rootPropertyName)) {
			return null;
		}
		else {
			throw new NotReadablePropertyException(getTargetClass(), propertyName);
		}
	}
	Object[] indices;
	try {
		indices = getIndices(propertyName);
	}
	catch (Exception e) {
		// could not convert indices
		throw createNotReadablePropertyException(propertyName, e);
	}
	return getPropertyValue(rootProperty, indices);
}
 

import org.springframework.beans.NotReadablePropertyException; //导入依赖的package包/类
@Override
public Object getPropertyValue(String propertyName) throws BeansException {
	Field field = this.fieldMap.get(propertyName);
	if (field == null) {
		throw new NotReadablePropertyException(
				this.target.getClass(), propertyName, "Field '" + propertyName + "' does not exist");
	}
	try {
		ReflectionUtils.makeAccessible(field);
		return field.get(this.target);
	}
	catch (IllegalAccessException ex) {
		throw new InvalidPropertyException(this.target.getClass(), propertyName, "Field is not accessible", ex);
	}
}