org.apache.bval.jsr.ClassValidator Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.bval.jsr;
import java.lang.reflect.Constructor;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.validation.ConstraintDeclarationException;
import javax.validation.ConstraintDefinitionException;
import javax.validation.ConstraintTarget;
import javax.validation.ConstraintViolation;
import javax.validation.ElementKind;
import javax.validation.ValidationException;
import javax.validation.executable.ExecutableValidator;
import javax.validation.groups.Default;
import javax.validation.metadata.BeanDescriptor;
import javax.validation.metadata.ConstraintDescriptor;
import javax.validation.metadata.ElementDescriptor;
import javax.validation.metadata.ParameterDescriptor;
import javax.validation.metadata.PropertyDescriptor;
import org.apache.bval.DynamicMetaBean;
import org.apache.bval.MetaBeanFinder;
import org.apache.bval.jsr.groups.Group;
import org.apache.bval.jsr.groups.Groups;
import org.apache.bval.jsr.groups.GroupsComputer;
import org.apache.bval.jsr.util.ClassHelper;
import org.apache.bval.jsr.util.NodeImpl;
import org.apache.bval.jsr.util.PathImpl;
import org.apache.bval.jsr.util.PathNavigation;
import org.apache.bval.jsr.util.Proxies;
import org.apache.bval.jsr.util.ValidationContextTraversal;
import org.apache.bval.model.Features;
import org.apache.bval.model.FeaturesCapable;
import org.apache.bval.model.MetaBean;
import org.apache.bval.model.MetaProperty;
import org.apache.bval.model.Validation;
import org.apache.bval.util.AccessStrategy;
import org.apache.bval.util.ValidationHelper;
import org.apache.bval.util.ObjectUtils;
import org.apache.bval.util.reflection.Reflection;
import org.apache.bval.util.reflection.TypeUtils;
import org.apache.commons.weaver.privilizer.Privilizing;
import org.apache.commons.weaver.privilizer.Privilizing.CallTo;
/**
* Objects of this class are able to validate bean instances (and the associated object graphs).
*
* Implementation is thread-safe.
*
* API class
*
* @version $Rev: 1514672 $ $Date: 2013-08-16 14:15:12 +0200 (ven., 16 août 2013) $
*
* @author Roman Stumm
* @author Carlos Vara
*/
@Privilizing(@CallTo(Reflection.class))
public class ClassValidator implements CascadingPropertyValidator, ExecutableValidator {
private static final Object VALIDATE_PROPERTY = new Object() {
@Override
public String toString() {
return "VALIDATE_PROPERTY";
}
};
/**
* {@link ApacheFactoryContext} used
*/
protected final ApacheFactoryContext factoryContext;
/**
* {@link GroupsComputer} used
*/
protected final GroupsComputer groupsComputer = new GroupsComputer();
private final MetaBeanFinder metaBeanFinder;
/**
* Create a new ClassValidator instance.
*
* @param factoryContext
*/
public ClassValidator(ApacheFactoryContext factoryContext) {
this.factoryContext = factoryContext;
metaBeanFinder = factoryContext.getMetaBeanFinder();
}
// Validator implementation
// --------------------------------------------------
/**
* {@inheritDoc} Validates all constraints on object.
*
* @param object object to validate
* @param groups group or list of groups targeted for validation (default to
* {@link javax.validation.groups.Default})
* @return constraint violations or an empty Set if none
* @throws IllegalArgumentException if object is null or if null is passed to the varargs groups
* @throws ValidationException if a non recoverable error happens during the validation
* process
*/
@Override
@SuppressWarnings("unchecked")
public Set> validate(T object, Class... groups) {
notNull("validated object", object);
checkGroups(groups);
try {
final Class objectClass = (Class) object.getClass();
final MetaBean objectMetaBean = metaBeanFinder.findForClass(objectClass);
final GroupValidationContext context = createContext(objectMetaBean, object, objectClass, groups);
return validateBeanWithGroups(context, context.getGroups());
} catch (final RuntimeException ex) {
throw unrecoverableValidationError(ex, object);
}
}
private Set> validateBeanWithGroups(final GroupValidationContext context,
final Groups sequence) {
final ConstraintValidationListener result = context.getListener();
// 1. process groups
for (final Group current : sequence.getGroups()) {
context.setCurrentGroup(current);
validateBeanNet(context);
}
// 2. process sequences
for (final List eachSeq : sequence.getSequences()) {
for (final Group current : eachSeq) {
context.setCurrentGroup(current);
validateBeanNet(context);
// if one of the group process in the sequence leads to one
// or more validation failure,
// the groups following in the sequence must not be
// processed
if (!result.isEmpty()) {
break;
}
}
if (!result.isEmpty()) {
break;
}
}
return result.getConstraintViolations();
}
/**
* {@inheritDoc} Validates all constraints placed on the property of object named
* propertyName.
*
* @param object object to validate
* @param propertyName property to validate (ie field and getter constraints). Nested
* properties may be referenced (e.g. prop[2].subpropA.subpropB)
* @param groups group or list of groups targeted for validation (default to
* {@link javax.validation.groups.Default})
* @return constraint violations or an empty Set if none
* @throws IllegalArgumentException if object is null, if propertyName
* null, empty or not a valid object property or if null is
* passed to the varargs groups
* @throws ValidationException if a non recoverable error happens during the validation
* process
*/
@Override
public Set> validateProperty(T object, String propertyName, Class... groups) {
return validateProperty(object, propertyName, false, groups);
}
/**
* {@inheritDoc}
*/
@Override
public Set> validateProperty(T object, String propertyName, boolean cascade,
Class... groups) {
notNull("validated object", object);
@SuppressWarnings("unchecked")
final Set> result =
validateValueImpl((Class) object.getClass(), object, propertyName, VALIDATE_PROPERTY, cascade, groups);
return result;
}
/**
* {@inheritDoc} Validates all constraints placed on the property named propertyName of the class
* beanType would the property value be value
*
* ConstraintViolation objects return null for {@link ConstraintViolation#getRootBean()} and
* {@link ConstraintViolation#getLeafBean()}
*
* @param beanType the bean type
* @param propertyName property to validate
* @param value property value to validate
* @param groups group or list of groups targeted for validation (default to
* {@link javax.validation.groups.Default})
* @return constraint violations or an empty Set if none
* @throws IllegalArgumentException if beanType is null, if
* propertyName null, empty or not a valid object
* property or if null is passed to the varargs groups
* @throws ValidationException if a non recoverable error happens during the validation
* process
*/
@Override
public Set> validateValue(Class beanType, String propertyName, Object value,
Class... groups) {
return validateValue(beanType, propertyName, value, false, groups);
}
/**
* {@inheritDoc}
*/
@Override
public Set> validateValue(Class beanType, String propertyName, Object value,
boolean cascade, Class... groups) {
return validateValueImpl(notNull("bean type", beanType), null, propertyName, value, cascade, groups);
}
/**
* {@inheritDoc} Return the descriptor object describing bean constraints. The returned object (and associated
* objects including ConstraintDescriptors) are immutable.
*
* @param clazz class or interface type evaluated
* @return the bean descriptor for the specified class.
* @throws IllegalArgumentException if clazz is null
* @throws ValidationException if a non recoverable error happens during the metadata
* discovery or if some constraints are invalid.
*/
@Override
public BeanDescriptor getConstraintsForClass(final Class clazz) {
notNull("class", clazz);
try {
final MetaBean metaBean = metaBeanFinder.findForClass(clazz); // don't throw an exception because of a missing validator here
BeanDescriptorImpl edesc = metaBean.getFeature(JsrFeatures.Bean.BEAN_DESCRIPTOR);
if (edesc == null) {
edesc = metaBean.initFeature(JsrFeatures.Bean.BEAN_DESCRIPTOR, createBeanDescriptor(metaBean));
}
return edesc;
} catch (final ConstraintDefinitionException definitionEx) {
throw definitionEx;
} catch (final ConstraintDeclarationException declarationEx) {
throw declarationEx;
} catch (final RuntimeException ex) {
throw new ValidationException("error retrieving constraints for " + clazz, ex);
}
}
/**
* {@inheritDoc} Return an instance of the specified type allowing access to provider-specific APIs. If the Bean
* Validation provider implementation does not support the specified class, ValidationException is
* thrown.
*
* @param type the class of the object to be returned.
* @return an instance of the specified class
* @throws ValidationException if the provider does not support the call.
*/
@Override
public T unwrap(Class type) {
// FIXME 2011-03-27 jw:
// This code is unsecure.
// It should allow only a fixed set of classes.
// Can't fix this because don't know which classes this method should support.
if (type.isAssignableFrom(getClass())) {
@SuppressWarnings("unchecked")
final T result = (T) this;
return result;
}
if (!(type.isInterface() || Modifier.isAbstract(type.getModifiers()))) {
return newInstance(type);
}
try {
final Class cls = Reflection.toClass(type.getName() + "Impl");
if (type.isAssignableFrom(cls)) {
@SuppressWarnings("unchecked")
final Class implClass = (Class) cls;
return newInstance(implClass);
}
} catch (ClassNotFoundException e) {
}
throw new ValidationException("Type " + type + " not supported");
}
@Override
public ExecutableValidator forExecutables() {
return this;
}
private T newInstance(final Class cls) {
final Constructor cons = Reflection.getDeclaredConstructor(cls, ApacheFactoryContext.class);
if (cons == null) {
throw new ValidationException("Cannot instantiate " + cls);
}
final boolean mustUnset = Reflection.setAccessible(cons, true);
try {
return cons.newInstance(factoryContext);
} catch (final Exception ex) {
throw new ValidationException("Cannot instantiate " + cls, ex);
} finally {
if (mustUnset) {
Reflection.setAccessible(cons, false);
}
}
}
// Helpers
// -------------------------------------------------------------------
/**
* Validates a bean and all its cascaded related beans for the currently defined group.
*
* Special code is present to manage the {@link Default} group.
*
* @param context The current context of this validation call. Must have its
* {@link GroupValidationContext#getCurrentGroup()} field set.
*/
protected void validateBeanNet(GroupValidationContext context) {
// If reached a cascaded bean which is null
if (context.getBean() == null) {
return;
}
// If reached a cascaded bean which has already been validated for the
// current group
if (!context.collectValidated()) {
return;
}
// ### First, validate the bean
// Default is a special case
if (context.getCurrentGroup().isDefault()) {
List defaultGroups = expandDefaultGroup(context);
final ConstraintValidationListener result = context.getListener();
// If the rootBean defines a GroupSequence
if (defaultGroups != null && defaultGroups.size() > 1) {
int numViolations = result.violationsSize();
// Validate the bean for each group in the sequence
final Group currentGroup = context.getCurrentGroup();
for (final Group each : defaultGroups) {
context.setCurrentGroup(each);
// ValidationHelper.validateBean(context);, doesn't match anymore because of @ConvertGroup
validateBean(context);
// Spec 3.4.3 - Stop validation if errors already found
if (result.violationsSize() > numViolations) {
break;
}
}
context.setCurrentGroup(currentGroup);
} else {
// For each class in the hierarchy of classes of rootBean,
// validate the constraints defined in that class according
// to the GroupSequence defined in the same class
// Obtain the full class hierarchy
final List> classHierarchy = new ArrayList>();
ClassHelper.fillFullClassHierarchyAsList(classHierarchy, context.getMetaBean().getBeanClass());
final Class initialOwner = context.getCurrentOwner();
// For each owner in the hierarchy
for (final Class owner : classHierarchy) {
context.setCurrentOwner(owner);
int numViolations = result.violationsSize();
// Obtain the group sequence of the owner, and use it for
// the constraints that belong to it
final List ownerDefaultGroups =
context.getMetaBean().getFeature("{GroupSequence:" + owner.getCanonicalName() + "}");
for (Group each : ownerDefaultGroups) {
context.setCurrentGroup(each);
validateBean(context);
// Spec 3.4.3 - Stop validation if errors already found
if (result.violationsSize() > numViolations) {
break;
}
}
}
context.setCurrentOwner(initialOwner);
context.setCurrentGroup(Group.DEFAULT);
}
}
// if not the default group, proceed as normal
else {
validateBean(context);
}
// ### Then, the cascaded beans (@Valid)
for (final MetaProperty prop : context.getMetaBean().getProperties()) {
final Group group = context.getCurrentGroup();
final Group mappedGroup;
final Object feature = prop.getFeature(JsrFeatures.Property.PropertyDescriptor);
if (feature == null) {
mappedGroup = group;
} else {
mappedGroup = PropertyDescriptorImpl.class.cast(feature).mapGroup(group);
}
if (group == mappedGroup) {
validateCascadedBean(context, prop, null);
} else {
final Groups propertyGroup = groupsComputer.computeGroups(new Class[] { mappedGroup.getGroup() });
validateCascadedBean(context, prop, propertyGroup);
}
context.setCurrentGroup(group);
}
}
// TODO: maybe add a GroupMapper to bval-core to ease this kind of thing and void to fork this method from ValidationHelper
private void validateBean(final GroupValidationContext context) {
// execute all property level validations
for (final PropertyDescriptor prop : getConstraintsForClass(context.getMetaBean().getBeanClass())
.getConstrainedProperties()) {
final PropertyDescriptorImpl impl = PropertyDescriptorImpl.class.cast(prop);
if (!impl.isValidated(impl)) {
checkValidationAppliesTo(impl.getConstraintDescriptors(), ConstraintTarget.PARAMETERS);
checkValidationAppliesTo(impl.getConstraintDescriptors(), ConstraintTarget.RETURN_VALUE);
impl.setValidated(impl); // we don't really care about concurrency here
}
final MetaProperty metaProperty = context.getMetaBean().getProperty(prop.getPropertyName());
context.setMetaProperty(metaProperty);
final Group current = context.getCurrentGroup();
context.setCurrentGroup(impl.mapGroup(current));
ValidationHelper.validateProperty(context);
context.setCurrentGroup(current);
}
// execute all bean level validations
context.setMetaProperty(null);
for (final Validation validation : context.getMetaBean().getValidations()) {
if (ConstraintValidation.class.isInstance(validation)) {
final ConstraintValidation constraintValidation = ConstraintValidation.class.cast(validation);
if (!constraintValidation.isValidated()) {
checkValidationAppliesTo(constraintValidation.getValidationAppliesTo(),
ConstraintTarget.PARAMETERS);
checkValidationAppliesTo(constraintValidation.getValidationAppliesTo(),
ConstraintTarget.RETURN_VALUE);
constraintValidation.setValidated(true);
}
}
validation.validate(context);
}
}
/**
* Checks if the the meta property prop defines a cascaded bean, and in case it does, validates it.
*
* @param context The current validation context.
* @param prop The property to cascade from (in case it is possible).
*/
private void validateCascadedBean(final GroupValidationContext context, final MetaProperty prop,
final Groups groups) {
final AccessStrategy[] access = prop.getFeature(Features.Property.REF_CASCADE);
if (access != null) { // different accesses to relation
// save old values from context
final Object bean = context.getBean();
final MetaBean mbean = context.getMetaBean();
// TODO implement Validation.groups support on related bean
// Class[] groups = prop.getFeature(JsrFeatures.Property.REF_GROUPS);
for (final AccessStrategy each : access) {
if (isCascadable(context, prop, each)) {
// modify context state for relationship-target bean
context.moveDown(prop, each);
// validate
if (groups == null) {
ValidationHelper.validateContext(context, new JsrValidationCallback(context),
factoryContext.isTreatMapsLikeBeans());
} else {
ValidationHelper.validateContext(context, new ValidationHelper.ValidateCallback() {
@Override
public void validate() {
validateBeanWithGroups(context, groups);
}
}, factoryContext.isTreatMapsLikeBeans());
}
// restore old values in context
context.moveUp(bean, mbean);
}
}
}
}
/**
* Before accessing a related bean (marked with {@link javax.validation.Valid}), the validator has to check if it is
* reachable and cascadable.
*
* @param context The current validation context.
* @param prop The property of the related bean.
* @param access The access strategy used to get the related bean value.
* @return true if the validator can access the related bean, false otherwise.
*/
private boolean isCascadable(GroupValidationContext context, MetaProperty prop, AccessStrategy access) {
PathImpl beanPath = context.getPropertyPath();
final NodeImpl node = new NodeImpl.PropertyNodeImpl(prop.getName());
if (beanPath == null) {
beanPath = PathImpl.create();
}
try {
if (!context.getTraversableResolver().isReachable(context.getBean(), node,
context.getRootMetaBean().getBeanClass(), beanPath, access.getElementType())) {
return false;
}
} catch (RuntimeException e) {
throw new ValidationException("Error in TraversableResolver.isReachable() for " + context.getBean(), e);
}
try {
if (!context.getTraversableResolver().isCascadable(context.getBean(), node,
context.getRootMetaBean().getBeanClass(), beanPath, access.getElementType())) {
return false;
}
} catch (RuntimeException e) {
throw new ValidationException("Error TraversableResolver.isCascadable() for " + context.getBean(), e);
}
return true;
}
/**
* in case of a default group return the list of groups for a redefined default GroupSequence
*
* @return null when no in default group or default group sequence not redefined
*/
private List expandDefaultGroup(GroupValidationContext context) {
if (context.getCurrentGroup().isDefault()) {
// mention if metaBean redefines the default group
final List groupSeq = context.getMetaBean().getFeature(JsrFeatures.Bean.GROUP_SEQUENCE);
if (groupSeq != null) {
context.getGroups().assertDefaultGroupSequenceIsExpandable(groupSeq);
}
return groupSeq;
}
return null;
}
/**
* Generate an unrecoverable validation error
*
* @param ex
* @param object
* @return a {@link RuntimeException} of the appropriate type
*/
protected static RuntimeException unrecoverableValidationError(RuntimeException ex, Object object) {
if (ex instanceof UnknownPropertyException || ex instanceof IncompatiblePropertyValueException) {
// Convert to IllegalArgumentException
return new IllegalArgumentException(ex.getMessage(), ex);
}
if (ex instanceof ValidationException) {
return ex; // do not wrap specific ValidationExceptions (or instances from subclasses)
}
String objectId;
if (object == null) {
objectId = "";
} else {
try {
objectId = object.toString();
} catch (Exception e) {
objectId = "";
}
}
return new ValidationException("error during validation of " + objectId, ex);
}
private void validatePropertyInGroup(final GroupValidationContext context) {
final Runnable helper;
if (context.getMetaProperty() == null) {
helper = new Runnable() {
@Override
public void run() {
ValidationHelper.validateBean(context);
}
};
} else {
helper = new Runnable() {
@Override
public void run() {
ValidationHelper.validateProperty(context);
}
};
}
final List defaultGroups = expandDefaultGroup(context);
if (defaultGroups == null) {
helper.run();
} else {
final Group currentGroup = context.getCurrentGroup();
for (Group each : defaultGroups) {
context.setCurrentGroup(each);
helper.run();
// continue validation, even if errors already found
}
context.setCurrentGroup(currentGroup); // restore
}
}
/**
* Create a {@link GroupValidationContext}.
*
* @param
* @param metaBean
* @param object
* @param objectClass
* @param groups
* @return {@link GroupValidationContext} instance
*/
protected GroupValidationContext createContext(MetaBean metaBean, T object, Class objectClass,
Class... groups) {
final ConstraintValidationListener listener = new ConstraintValidationListener(object, objectClass);
final GroupValidationContextImpl context = new GroupValidationContextImpl(listener,
factoryContext.getMessageInterpolator(), factoryContext.getTraversableResolver(),
factoryContext.getParameterNameProvider(), factoryContext.getConstraintValidatorFactory(), metaBean);
context.setBean(object, metaBean);
context.setGroups(groupsComputer.computeGroups(groups));
return context;
}
protected GroupValidationContext createInvocableContext(MetaBean metaBean, T object, Class objectClass,
Class... groups) {
final ConstraintValidationListener listener = new ConstraintValidationListener(object, objectClass);
final GroupValidationContextImpl context = new GroupValidationContextImpl(listener,
factoryContext.getMessageInterpolator(), factoryContext.getTraversableResolver(),
factoryContext.getParameterNameProvider(), factoryContext.getConstraintValidatorFactory(), metaBean);
context.setBean(object, metaBean);
final Groups computedGroup = groupsComputer.computeGroups(groups);
if (Collections.singletonList(Group.DEFAULT).equals(computedGroup.getGroups())
&& metaBean.getFeature(JsrFeatures.Bean.GROUP_SEQUENCE) != null) {
final Groups sequence = new Groups();
@SuppressWarnings("unchecked")
final List sequenceGroups =
List.class.cast(metaBean.getFeature(JsrFeatures.Bean.GROUP_SEQUENCE));
sequence.getGroups().addAll(sequenceGroups);
context.setGroups(sequence);
} else {
context.setGroups(computedGroup);
}
return context;
}
/**
* Create a {@link BeanDescriptorImpl}
*
* @param metaBean
* @return {@link BeanDescriptorImpl} instance
*/
protected BeanDescriptorImpl createBeanDescriptor(MetaBean metaBean) {
return new BeanDescriptorImpl(factoryContext, metaBean);
}
/**
* Checks that the property name is valid according to spec Section 4.1.1 i. Throws an
* {@link IllegalArgumentException} if it is not.
*
* @param propertyName Property name to check.
*/
private void checkPropertyName(String propertyName) {
if (propertyName == null || propertyName.trim().isEmpty()) {
throw new IllegalArgumentException("Property path cannot be null or empty.");
}
}
/**
* Checks that the groups array is valid according to spec Section 4.1.1 i. Throws an
* {@link IllegalArgumentException} if it is not.
*
* @param groups The groups to check.
*/
private void checkGroups(Class[] groups) {
for (final Class c : notNull("groups", groups)) {
notNull("group", c);
}
}
@Override
public Set> validateConstructorParameters(Constructor constructor,
Object[] parameterValues, Class... gps) {
notNull("Constructor", constructor);
notNull("Groups", gps);
notNull("Parameters", parameterValues);
final Class declaringClass = constructor.getDeclaringClass();
final ConstructorDescriptorImpl constructorDescriptor = ConstructorDescriptorImpl.class
.cast(getConstraintsForClass(declaringClass).getConstraintsForConstructor(constructor.getParameterTypes()));
if (constructorDescriptor == null) { // no constraint
return Collections.emptySet();
}
// sanity checks
if (!constructorDescriptor.isValidated(constructor)) {
if (parameterValues.length == 0) {
checkValidationAppliesTo(Collections.singleton(constructorDescriptor.getCrossParameterDescriptor()),
ConstraintTarget.PARAMETERS);
checkValidationAppliesTo(constructorDescriptor.getParameterDescriptors(), ConstraintTarget.PARAMETERS);
} else {
checkValidationAppliesTo(Collections.singleton(constructorDescriptor.getCrossParameterDescriptor()),
ConstraintTarget.IMPLICIT);
checkValidationAppliesTo(constructorDescriptor.getParameterDescriptors(), ConstraintTarget.IMPLICIT);
}
constructorDescriptor.setValidated(constructor);
}
// validations
return validateInvocationParameters(constructor, parameterValues, constructorDescriptor, gps,
new NodeImpl.ConstructorNodeImpl(declaringClass.getSimpleName(),
Arrays.asList(constructor.getParameterTypes())),
null);
}
private Set> validateInvocationParameters(final Member invocable,
final Object[] parameterValues, final InvocableElementDescriptor constructorDescriptor, final Class[] gps,
final NodeImpl rootNode, final Object rootBean) {
final Set> violations = new HashSet>();
@SuppressWarnings("unchecked")
final GroupValidationContext> parametersContext = createInvocableContext(
constructorDescriptor.getMetaBean(), rootBean, Class.class.cast(invocable.getDeclaringClass()), gps);
@SuppressWarnings("unchecked")
final GroupValidationContext © 2015 - 2025 Weber Informatics LLC | Privacy Policy