HV-1587 Reduce significantly the tracking of already validated beans and constraints

Author: gsmet

engine/src/main/java/org/hibernate/validator/internal/engine/ValidationContext.java

@@ -16,6 +16,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -38,6 +39,7 @@
 import org.hibernate.validator.internal.engine.path.PathImpl;
 import org.hibernate.validator.internal.metadata.BeanMetaDataManager;
 import org.hibernate.validator.internal.metadata.aggregated.BeanMetaData;
+import org.hibernate.validator.internal.metadata.aggregated.ExecutableMetaData;
 import org.hibernate.validator.internal.metadata.core.MetaConstraint;
 import org.hibernate.validator.internal.util.ExecutableParameterNameProvider;
 import org.hibernate.validator.internal.util.logging.Log;
@@ -99,6 +101,11 @@ public class ValidationContext<T> {
 	 */
 	private final Object executableReturnValue;
 
+	/**
+	 * The metadata of the Executable. Will be non empty if we are in the case of method validation and the method is constrained.
+	 */
+	private final Optional<ExecutableMetaData> executableMetaData;
+
 	/**
 	 * The set of already processed meta constraints per bean - path ({@link BeanPathMetaConstraintProcessedUnit}).
 	 */
@@ -139,6 +146,11 @@ public class ValidationContext<T> {
 	 */
 	private final HibernateConstraintValidatorInitializationContext constraintValidatorInitializationContext;
 
+	/**
+	 * Indicates if the tracking of already validated bean should be disabled.
+	 */
+	private final boolean disableAlreadyValidatedBeanTracking;
+
 	/**
 	 * The name of the validated (leaf) property in case of a validateProperty()/validateValue() call.
 	 */
@@ -155,7 +167,8 @@ private ValidationContext(ValidationOperation validationOperation,
 			BeanMetaData<T> rootBeanMetaData,
 			Executable executable,
 			Object[] executableParameters,
-			Object executableReturnValue) {
+			Object executableReturnValue,
+			Optional<ExecutableMetaData> executableMetaData) {
 		this.validationOperation = validationOperation;
 
 		this.constraintValidatorManager = constraintValidatorManager;
@@ -175,6 +188,10 @@ private ValidationContext(ValidationOperation validationOperation,
 		this.processedPathUnits = new HashSet<>();
 		this.processedPathsPerBean = new IdentityHashMap<>();
 		this.failingConstraintViolations = newHashSet();
+
+		this.executableMetaData = executableMetaData;
+
+		this.disableAlreadyValidatedBeanTracking = buildDisableAlreadyValidatedBeanTracking( validationOperation, rootBeanMetaData, executableMetaData );
 	}
 
 	public static ValidationContextBuilder getValidationContextBuilder(
@@ -211,6 +228,10 @@ public Executable getExecutable() {
 		return executable;
 	}
 
+	public Optional<ExecutableMetaData> getExecutableMetaData() {
+		return executableMetaData;
+	}
+
 	public TraversableResolver getTraversableResolver() {
 		return traversableResolver;
 	}
@@ -259,6 +280,10 @@ public ConstraintValidatorFactory getConstraintValidatorFactory() {
 	}
 
 	public boolean isBeanAlreadyValidated(Object value, Class<?> group, PathImpl path) {
+		if ( disableAlreadyValidatedBeanTracking ) {
+			return false;
+		}
+
 		boolean alreadyValidated;
 		alreadyValidated = isAlreadyValidatedForCurrentGroup( value, group );
 
@@ -270,6 +295,10 @@ public boolean isBeanAlreadyValidated(Object value, Class<?> group, PathImpl pat
 	}
 
 	public void markCurrentBeanAsProcessed(ValueContext<?, ?> valueContext) {
+		if ( disableAlreadyValidatedBeanTracking ) {
+			return;
+		}
+
 		markCurrentBeanAsProcessedForCurrentGroup( valueContext.getCurrentBean(), valueContext.getCurrentGroup() );
 		markCurrentBeanAsProcessedForCurrentPath( valueContext.getCurrentBean(), valueContext.getPropertyPath() );
 	}
@@ -348,10 +377,22 @@ public ConstraintViolation<T> createConstraintViolation(ValueContext<?, ?> local
 	}
 
 	public boolean hasMetaConstraintBeenProcessed(Object bean, Path path, MetaConstraint<?> metaConstraint) {
+		// this is only useful if the constraint is defined for more than 1 group as in the case it's only
+		// defined for one group, there is no chance it's going to be called twice.
+		if ( metaConstraint.isDefinedForOneGroupOnly() ) {
+			return false;
+		}
+
 		return processedPathUnits.contains( new BeanPathMetaConstraintProcessedUnit( bean, path, metaConstraint ) );
 	}
 
 	public void markConstraintProcessed(Object bean, Path path, MetaConstraint<?> metaConstraint) {
+		// this is only useful if the constraint is defined for more than 1 group as in the case it's only
+		// defined for one group, there is no chance it's going to be called twice.
+		if ( metaConstraint.isDefinedForOneGroupOnly()  ) {
+			return;
+		}
+
 		processedPathUnits.add( new BeanPathMetaConstraintProcessedUnit( bean, path, metaConstraint ) );
 	}
 
@@ -372,6 +413,33 @@ public String toString() {
 		return sb.toString();
 	}
 
+	private static boolean buildDisableAlreadyValidatedBeanTracking(ValidationOperation validationOperation, BeanMetaData<?> rootBeanMetaData,
+			Optional<ExecutableMetaData> executableMetaData) {
+		switch ( validationOperation ) {
+			case BEAN_VALIDATION:
+			case PROPERTY_VALIDATION:
+			case VALUE_VALIDATION:
+				// note that in the case of property and value validation, we are considering the root bean, whereas we
+				// could consider the bean of the property or the value. We don't really have the info here though so it
+				// will do for now.
+				return !rootBeanMetaData.hasCascadingProperties();
+			case PARAMETER_VALIDATION:
+				if ( !executableMetaData.isPresent() ) {
+					// the method is unconstrained so there's no need to worry about the tracking
+					return false;
+				}
+				return !executableMetaData.get().hasCascadingParameters();
+			case RETURN_VALUE_VALIDATION:
+				if ( !executableMetaData.isPresent() ) {
+					// the method is unconstrained so there's no need to worry about the tracking
+					return false;
+				}
+				return !executableMetaData.get().getReturnValueMetaData().isCascading();
+			default:
+				return false;
+		}
+	}
+
 	private String interpolate(String messageTemplate,
 			Object validatedValue,
 			ConstraintDescriptor<?> descriptor,
@@ -487,7 +555,8 @@ public <T> ValidationContext<T> forValidate(T rootBean) {
 					beanMetaDataManager.getBeanMetaData( rootBeanClass ),
 					null, //executable
 					null, //executable parameters
-					null //executable return value
+					null, //executable return value
+					null //executable metadata
 			);
 		}
 
@@ -506,7 +575,8 @@ public <T> ValidationContext<T> forValidateProperty(T rootBean) {
 					beanMetaDataManager.getBeanMetaData( rootBeanClass ),
 					null, //executable
 					null, //executable parameters
-					null //executable return value
+					null, //executable return value
+					null //executable metadata
 			);
 		}
 
@@ -523,7 +593,8 @@ public <T> ValidationContext<T> forValidateValue(Class<T> rootBeanClass) {
 					beanMetaDataManager.getBeanMetaData( rootBeanClass ),
 					null, //executable
 					null, //executable parameters
-					null //executable return value
+					null, //executable return value
+					null //executable metadata
 			);
 		}
 
@@ -534,6 +605,8 @@ public <T> ValidationContext<T> forValidateParameters(
 				Object[] executableParameters) {
 			@SuppressWarnings("unchecked")
 			Class<T> rootBeanClass = rootBean != null ? (Class<T>) rootBean.getClass() : (Class<T>) executable.getDeclaringClass();
+			BeanMetaData<T> rootBeanMetaData = beanMetaDataManager.getBeanMetaData( rootBeanClass );
+
 			return new ValidationContext<>(
 					ValidationOperation.PARAMETER_VALIDATION,
 					constraintValidatorManager,
@@ -543,10 +616,11 @@ public <T> ValidationContext<T> forValidateParameters(
 					constraintValidatorInitializationContext,
 					rootBean,
 					rootBeanClass,
-					beanMetaDataManager.getBeanMetaData( rootBeanClass ),
+					rootBeanMetaData,
 					executable,
 					executableParameters,
-					null //executable return value
+					null, //executable return value
+					rootBeanMetaData.getMetaDataFor( executable )
 			);
 		}
 
@@ -556,6 +630,7 @@ public <T> ValidationContext<T> forValidateReturnValue(
 				Object executableReturnValue) {
 			@SuppressWarnings("unchecked")
 			Class<T> rootBeanClass = rootBean != null ? (Class<T>) rootBean.getClass() : (Class<T>) executable.getDeclaringClass();
+			BeanMetaData<T> rootBeanMetaData = beanMetaDataManager.getBeanMetaData( rootBeanClass );
 			return new ValidationContext<>(
 					ValidationOperation.RETURN_VALUE_VALIDATION,
 					constraintValidatorManager,
@@ -568,7 +643,8 @@ public <T> ValidationContext<T> forValidateReturnValue(
 					beanMetaDataManager.getBeanMetaData( rootBeanClass ),
 					executable,
 					null, //executable parameters
-					executableReturnValue
+					executableReturnValue,
+					rootBeanMetaData.getMetaDataFor( executable )
 			);
 		}
 	}

engine/src/main/java/org/hibernate/validator/internal/engine/ValidatorImpl.java

@@ -814,7 +814,7 @@ private <T> void validateParametersInContext(ValidationContext<T> validationCont
 			ValidationOrder validationOrder) {
 		BeanMetaData<T> beanMetaData = validationContext.getRootBeanMetaData();
 
-		Optional<ExecutableMetaData> executableMetaDataOptional = beanMetaData.getMetaDataFor( validationContext.getExecutable() );
+		Optional<ExecutableMetaData> executableMetaDataOptional = validationContext.getExecutableMetaData();
 
 		if ( !executableMetaDataOptional.isPresent() ) {
 			// the method is unconstrained
@@ -1011,7 +1011,7 @@ private <T> ValueContext<T, Object> getExecutableValueContext(T object, Executab
 	private <V, T> void validateReturnValueInContext(ValidationContext<T> validationContext, T bean, V value, ValidationOrder validationOrder) {
 		BeanMetaData<T> beanMetaData = validationContext.getRootBeanMetaData();
 
-		Optional<ExecutableMetaData> executableMetaDataOptional = beanMetaData.getMetaDataFor( validationContext.getExecutable() );
+		Optional<ExecutableMetaData> executableMetaDataOptional = validationContext.getExecutableMetaData();
 
 		if ( !executableMetaDataOptional.isPresent() ) {
 			// the method is unconstrained

engine/src/main/java/org/hibernate/validator/internal/metadata/aggregated/BeanMetaData.java

@@ -113,4 +113,9 @@ public interface BeanMetaData<T> extends Validatable {
 	 *         element itself and goes up the hierarchy chain. Interfaces are not included.
 	 */
 	List<Class<? super T>> getClassHierarchy();
+
+	/**
+	 * @return {@code true} if there is at least one cascading property in the bean metadata, {@code false} otherwise.
+	 */
+	boolean hasCascadingProperties();
 }

engine/src/main/java/org/hibernate/validator/internal/metadata/aggregated/BeanMetaDataImpl.java

@@ -134,6 +134,11 @@ public final class BeanMetaDataImpl<T> implements BeanMetaData<T> {
 	@Immutable
 	private final Set<Cascadable> cascadedProperties;
 
+	/**
+	 * Indicates if the bean has at least one cascading property.
+	 */
+	private final boolean hasCascadingProperties;
+
 	/**
 	 * The bean descriptor for this bean.
 	 */
@@ -216,6 +221,7 @@ public BeanMetaDataImpl(Class<T> beanClass,
 
 		this.hasConstraints = hasConstraints;
 		this.cascadedProperties = CollectionHelper.toImmutableSet( cascadedProperties );
+		this.hasCascadingProperties = cascadedProperties.size() > 0;
 		this.allMetaConstraints = CollectionHelper.toImmutableSet( allMetaConstraints );
 
 		this.classHierarchyWithoutInterfaces = CollectionHelper.toImmutableList( ClassHierarchyHelper.getHierarchy(
@@ -285,6 +291,11 @@ public Set<Cascadable> getCascadables() {
 		return cascadedProperties;
 	}
 
+	@Override
+	public boolean hasCascadingProperties() {
+		return hasCascadingProperties;
+	}
+
 	@Override
 	public PropertyMetaData getMetaDataFor(String propertyName) {
 		PropertyMetaData propertyMetaData = propertyMetaDataMap.get( propertyName );

engine/src/main/java/org/hibernate/validator/internal/metadata/aggregated/ExecutableMetaData.java

@@ -76,6 +76,8 @@ public class ExecutableMetaData extends AbstractConstraintMetaData {
 	private final ReturnValueMetaData returnValueMetaData;
 	private final ElementKind kind;
 
+	private final boolean hasCascadingParameters;
+
 	private ExecutableMetaData(
 			String name,
 			Type returnType,
@@ -84,7 +86,7 @@ private ExecutableMetaData(
 			Set<String> signatures,
 			Set<MetaConstraint<?>> returnValueConstraints,
 			Set<MetaConstraint<?>> returnValueContainerElementConstraints,
-			List<ParameterMetaData> parameterMetaData,
+			List<ParameterMetaData> parameterMetaDataList,
 			Set<MetaConstraint<?>> crossParameterConstraints,
 			CascadingMetaData cascadingMetaData,
 			boolean isConstrained,
@@ -99,7 +101,7 @@ private ExecutableMetaData(
 		);
 
 		this.parameterTypes = parameterTypes;
-		this.parameterMetaDataList = CollectionHelper.toImmutableList( parameterMetaData );
+		this.parameterMetaDataList = CollectionHelper.toImmutableList( parameterMetaDataList );
 		this.crossParameterConstraints = CollectionHelper.toImmutableSet( crossParameterConstraints );
 		this.signatures = signatures;
 		this.returnValueMetaData = new ReturnValueMetaData(
@@ -110,6 +112,8 @@ private ExecutableMetaData(
 		);
 		this.isGetter = isGetter;
 		this.kind = kind;
+
+		this.hasCascadingParameters = buildHasCascadingParameters( parameterMetaDataList );
 	}
 
 	/**
@@ -240,6 +244,19 @@ public boolean equals(Object obj) {
 		return true;
 	}
 
+	public boolean hasCascadingParameters() {
+		return hasCascadingParameters;
+	}
+
+	private boolean buildHasCascadingParameters(List<ParameterMetaData> parameterMetaDataList) {
+		for ( ParameterMetaData parameterMetaData : parameterMetaDataList ) {
+			if ( parameterMetaData.isCascading() ) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 	/**
 	 * Creates new {@link ExecutableMetaData} instances.
 	 *

engine/src/main/java/org/hibernate/validator/internal/metadata/core/MetaConstraint.java

@@ -55,6 +55,12 @@ public class MetaConstraint<A extends Annotation> {
 
 	private final int hashCode;
 
+	/**
+	 * Indicates if the constraint is defined for one group only: used to optimize already validated constraints
+	 * tracking.
+	 */
+	private final boolean isDefinedForOneGroupOnly;
+
 	/**
 	 * @param constraintDescriptor The constraint descriptor for this constraint
 	 * @param location meta data about constraint placement
@@ -67,6 +73,7 @@ public class MetaConstraint<A extends Annotation> {
 		this.location = location;
 		this.valueExtractionPath = getValueExtractionPath( valueExtractionPath );
 		this.hashCode = buildHashCode( constraintDescriptor, location );
+		this.isDefinedForOneGroupOnly = constraintDescriptor.getGroups().size() <= 1;
 	}
 
 	private static ValueExtractionPathNode getValueExtractionPath(List<ContainerClassTypeParameterAndExtractor> valueExtractionPath) {
@@ -85,6 +92,10 @@ public final Set<Class<?>> getGroupList() {
 		return constraintTree.getDescriptor().getGroups();
 	}
 
+	public final boolean isDefinedForOneGroupOnly() {
+		return isDefinedForOneGroupOnly;
+	}
+
 	public final ConstraintDescriptorImpl<A> getDescriptor() {
 		return constraintTree.getDescriptor();
 	}