HV-1697 Reduce memory allocation in ValidationContexts

Author: gsmet

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

@@ -161,10 +161,6 @@ public final <T> Set<ConstraintViolation<T>> validate(T object, Class<?>... grou
 
 		BaseBeanValidationContext<T> validationContext = getValidationContextBuilder().forValidate( rootBeanClass, rootBeanMetaData, object );
 
-		if ( !validationContext.getRootBeanMetaData().hasConstraints() ) {
-			return Collections.emptySet();
-		}
-
 		ValidationOrder validationOrder = determineGroupValidationOrder( groups );
 		BeanValueContext<?, Object> valueContext = ValueContexts.getLocalExecutionContextForBean(
 				validatorScopedContext.getParameterNameProvider(),
@@ -270,6 +266,10 @@ private <T> Set<ConstraintViolation<T>> validateParameters(T object, Executable
 		Class<T> rootBeanClass = object != null ? (Class<T>) object.getClass() : (Class<T>) executable.getDeclaringClass();
 		BeanMetaData<T> rootBeanMetaData = beanMetaDataManager.getBeanMetaData( rootBeanClass );
 
+		if ( !rootBeanMetaData.hasConstraints() ) {
+			return Collections.emptySet();
+		}
+
 		ExecutableValidationContext<T> validationContext = getValidationContextBuilder().forValidateParameters(
 				rootBeanClass,
 				rootBeanMetaData,
@@ -278,10 +278,6 @@ private <T> Set<ConstraintViolation<T>> validateParameters(T object, Executable
 				parameterValues
 		);
 
-		if ( !validationContext.getRootBeanMetaData().hasConstraints() ) {
-			return Collections.emptySet();
-		}
-
 		ValidationOrder validationOrder = determineGroupValidationOrder( groups );
 
 		validateParametersInContext( validationContext, parameterValues, validationOrder );
@@ -296,6 +292,9 @@ private <T> Set<ConstraintViolation<T>> validateReturnValue(T object, Executable
 		Class<T> rootBeanClass = object != null ? (Class<T>) object.getClass() : (Class<T>) executable.getDeclaringClass();
 		BeanMetaData<T> rootBeanMetaData = beanMetaDataManager.getBeanMetaData( rootBeanClass );
 
+		if ( !rootBeanMetaData.hasConstraints() ) {
+			return Collections.emptySet();
+		}
 
 		ExecutableValidationContext<T> validationContext = getValidationContextBuilder().forValidateReturnValue(
 				rootBeanClass,
@@ -305,10 +304,6 @@ private <T> Set<ConstraintViolation<T>> validateReturnValue(T object, Executable
 				returnValue
 		);
 
-		if ( !validationContext.getRootBeanMetaData().hasConstraints() ) {
-			return Collections.emptySet();
-		}
-
 		ValidationOrder validationOrder = determineGroupValidationOrder( groups );
 
 		validateReturnValueInContext( validationContext, object, returnValue, validationOrder );

engine/src/main/java/org/hibernate/validator/internal/engine/validationcontext/AbstractValidationContext.java

@@ -6,9 +6,8 @@
  */
 package org.hibernate.validator.internal.engine.validationcontext;
 
-import static org.hibernate.validator.internal.util.CollectionHelper.newHashSet;
-
 import java.lang.invoke.MethodHandles;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.IdentityHashMap;
 import java.util.Iterator;
@@ -35,6 +34,7 @@
 import org.hibernate.validator.internal.metadata.descriptor.ConstraintDescriptorImpl;
 import org.hibernate.validator.internal.util.logging.Log;
 import org.hibernate.validator.internal.util.logging.LoggerFactory;
+import org.hibernate.validator.internal.util.stereotypes.Lazy;
 
 /**
  * Context object keeping track of all required data for a validation call.
@@ -73,49 +73,53 @@ abstract class AbstractValidationContext<T> implements BaseBeanValidationContext
 	private final BeanMetaData<T> rootBeanMetaData;
 
 	/**
-	 * The set of already processed meta constraints per bean - path ({@link BeanPathMetaConstraintProcessedUnit}).
+	 * The constraint factory which should be used in this context.
 	 */
-	private final Set<BeanPathMetaConstraintProcessedUnit> processedPathUnits;
+	private final ConstraintValidatorFactory constraintValidatorFactory;
 
 	/**
-	 * The set of already processed groups per bean ({@link BeanGroupProcessedUnit}).
+	 * Context containing all {@link Validator} level helpers and configuration properties.
 	 */
-	private final Set<BeanGroupProcessedUnit> processedGroupUnits;
+	protected final ValidatorScopedContext validatorScopedContext;
 
 	/**
-	 * Maps an object to a list of paths in which it has been validated. The objects are the bean instances.
+	 * Allows a JPA provider to decide whether a property should be validated.
 	 */
-	private final Map<Object, Set<PathImpl>> processedPathsPerBean;
+	private final TraversableResolver traversableResolver;
 
 	/**
-	 * Contains all failing constraints so far.
+	 * The constraint validator initialization context.
 	 */
-	private final Set<ConstraintViolation<T>> failingConstraintViolations;
+	private final HibernateConstraintValidatorInitializationContext constraintValidatorInitializationContext;
 
 	/**
-	 * The constraint factory which should be used in this context.
+	 * Indicates if the tracking of already validated bean should be disabled.
 	 */
-	private final ConstraintValidatorFactory constraintValidatorFactory;
+	private final boolean disableAlreadyValidatedBeanTracking;
 
 	/**
-	 * Context containing all {@link Validator} level helpers and configuration properties.
+	 * The set of already processed meta constraints per bean - path ({@link BeanPathMetaConstraintProcessedUnit}).
 	 */
-	protected final ValidatorScopedContext validatorScopedContext;
+	@Lazy
+	private Set<BeanPathMetaConstraintProcessedUnit> processedPathUnits;
 
 	/**
-	 * Allows a JPA provider to decide whether a property should be validated.
+	 * The set of already processed groups per bean ({@link BeanGroupProcessedUnit}).
 	 */
-	private final TraversableResolver traversableResolver;
+	@Lazy
+	private Set<BeanGroupProcessedUnit> processedGroupUnits;
 
 	/**
-	 * The constraint validator initialization context.
+	 * Maps an object to a list of paths in which it has been validated. The objects are the bean instances.
 	 */
-	private final HibernateConstraintValidatorInitializationContext constraintValidatorInitializationContext;
+	@Lazy
+	private Map<Object, Set<PathImpl>> processedPathsPerBean;
 
 	/**
-	 * Indicates if the tracking of already validated bean should be disabled.
+	 * Contains all failing constraints so far.
 	 */
-	private final boolean disableAlreadyValidatedBeanTracking;
+	@Lazy
+	private Set<ConstraintViolation<T>> failingConstraintViolations;
 
 	protected AbstractValidationContext(
 			ConstraintValidatorManager constraintValidatorManager,
@@ -138,11 +142,6 @@ protected AbstractValidationContext(
 		this.rootBeanClass = rootBeanClass;
 		this.rootBeanMetaData = rootBeanMetaData;
 
-		this.processedGroupUnits = new HashSet<>();
-		this.processedPathUnits = new HashSet<>();
-		this.processedPathsPerBean = new IdentityHashMap<>();
-		this.failingConstraintViolations = newHashSet();
-
 		this.disableAlreadyValidatedBeanTracking = disableAlreadyValidatedBeanTracking;
 	}
 
@@ -214,6 +213,10 @@ public void markCurrentBeanAsProcessed(ValueContext<?, ?> valueContext) {
 
 	@Override
 	public Set<ConstraintViolation<T>> getFailingConstraints() {
+		if ( failingConstraintViolations == null ) {
+			return Collections.emptySet();
+		}
+
 		return failingConstraintViolations;
 	}
 
@@ -235,7 +238,7 @@ public void addConstraintFailure(
 		// at this point we make a copy of the path to avoid side effects
 		Path path = PathImpl.createCopy( constraintViolationCreationContext.getPath() );
 
-		this.failingConstraintViolations.add(
+		getInitializedFailingConstraintViolations().add(
 				createConstraintViolation(
 						messageTemplate,
 						interpolatedMessage,
@@ -263,7 +266,7 @@ public boolean hasMetaConstraintBeenProcessed(Object bean, Path path, MetaConstr
 			return false;
 		}
 
-		return processedPathUnits.contains( new BeanPathMetaConstraintProcessedUnit( bean, path, metaConstraint ) );
+		return getInitializedProcessedPathUnits().contains( new BeanPathMetaConstraintProcessedUnit( bean, path, metaConstraint ) );
 	}
 
 	@Override
@@ -274,7 +277,7 @@ public void markConstraintProcessed(Object bean, Path path, MetaConstraint<?> me
 			return;
 		}
 
-		processedPathUnits.add( new BeanPathMetaConstraintProcessedUnit( bean, path, metaConstraint ) );
+		getInitializedProcessedPathUnits().add( new BeanPathMetaConstraintProcessedUnit( bean, path, metaConstraint ) );
 	}
 
 	@Override
@@ -321,7 +324,7 @@ private String interpolate(
 	}
 
 	private boolean isAlreadyValidatedForPath(Object value, PathImpl path) {
-		Set<PathImpl> pathSet = processedPathsPerBean.get( value );
+		Set<PathImpl> pathSet = getInitializedProcessedPathsPerBean().get( value );
 		if ( pathSet == null ) {
 			return false;
 		}
@@ -352,17 +355,52 @@ private boolean isSubPathOf(Path p1, Path p2) {
 	}
 
 	private boolean isAlreadyValidatedForCurrentGroup(Object value, Class<?> group) {
-		return processedGroupUnits.contains( new BeanGroupProcessedUnit( value, group ) );
+		return getInitializedProcessedGroupUnits().contains( new BeanGroupProcessedUnit( value, group ) );
 	}
 
 	private void markCurrentBeanAsProcessedForCurrentPath(Object bean, PathImpl path) {
 		// HV-1031 The path object is mutated as we traverse the object tree, hence copy it before saving it
-		processedPathsPerBean.computeIfAbsent( bean, b -> new HashSet<>() )
-				.add( PathImpl.createCopy( path ) );
+		Map<Object, Set<PathImpl>> processedPathsPerBean = getInitializedProcessedPathsPerBean();
+
+		Set<PathImpl> processedPaths = processedPathsPerBean.get( bean );
+		if ( processedPaths == null ) {
+			processedPaths = new HashSet<>();
+			processedPathsPerBean.put( bean, processedPaths );
+		}
+
+		processedPaths.add( PathImpl.createCopy( path ) );
 	}
 
 	private void markCurrentBeanAsProcessedForCurrentGroup(Object bean, Class<?> group) {
-		processedGroupUnits.add( new BeanGroupProcessedUnit( bean, group ) );
+		getInitializedProcessedGroupUnits().add( new BeanGroupProcessedUnit( bean, group ) );
+	}
+
+	private Set<BeanPathMetaConstraintProcessedUnit> getInitializedProcessedPathUnits() {
+		if ( processedPathUnits == null ) {
+			processedPathUnits = new HashSet<>();
+		}
+		return processedPathUnits;
+	}
+
+	private Set<BeanGroupProcessedUnit> getInitializedProcessedGroupUnits() {
+		if ( processedGroupUnits == null ) {
+			processedGroupUnits = new HashSet<>();
+		}
+		return processedGroupUnits;
+	}
+
+	private Map<Object, Set<PathImpl>> getInitializedProcessedPathsPerBean() {
+		if ( processedPathsPerBean == null ) {
+			processedPathsPerBean = new IdentityHashMap<>();
+		}
+		return processedPathsPerBean;
+	}
+
+	private Set<ConstraintViolation<T>> getInitializedFailingConstraintViolations() {
+		if ( failingConstraintViolations == null ) {
+			failingConstraintViolations = new HashSet<>();
+		}
+		return failingConstraintViolations;
 	}
 
 	private static final class BeanPathMetaConstraintProcessedUnit {

engine/src/main/java/org/hibernate/validator/internal/util/stereotypes/Lazy.java

@@ -0,0 +1,23 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.internal.util.stereotypes;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Documents that the value assigned to the annotated field is lazily initialized and shouldn't be accessed directly but
+ * via a getter.
+ *
+ * @author Guillaume Smet
+ */
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.FIELD)
+public @interface Lazy {
+}