HV-1767 Reduce the overhead of ConstraintHelper initialization in the predefined scope case

engine/src/main/java/org/hibernate/validator/PredefinedScopeHibernateValidatorConfiguration.java

@@ -20,6 +20,9 @@
 @Incubating
 public interface PredefinedScopeHibernateValidatorConfiguration extends BaseHibernateValidatorConfiguration<PredefinedScopeHibernateValidatorConfiguration> {
 
+	@Incubating
+	PredefinedScopeHibernateValidatorConfiguration builtinConstraints(Set<String> constraints);
+
 	@Incubating
 	PredefinedScopeHibernateValidatorConfiguration initializeBeanMetaData(Set<Class<?>> beanClassesToInitialize);
 

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

@@ -54,6 +54,7 @@
 import org.hibernate.validator.internal.util.privilegedactions.GetClassLoader;
 import org.hibernate.validator.internal.util.privilegedactions.GetInstancesFromServiceLoader;
 import org.hibernate.validator.internal.util.privilegedactions.SetContextClassLoader;
+import org.hibernate.validator.internal.util.stereotypes.Lazy;
 import org.hibernate.validator.internal.xml.config.ValidationBootstrapParameters;
 import org.hibernate.validator.internal.xml.config.ValidationXmlParser;
 import org.hibernate.validator.messageinterpolation.ResourceBundleMessageInterpolator;
@@ -88,11 +89,19 @@ public abstract class AbstractConfigurationImpl<T extends BaseHibernateValidator
 	/**
 	 * Built lazily so RBMI and its dependency on EL is only initialized if actually needed
 	 */
+	@Lazy
 	private ResourceBundleLocator defaultResourceBundleLocator;
+	@Lazy
 	private MessageInterpolator defaultMessageInterpolator;
+	@Lazy
 	private MessageInterpolator messageInterpolator;
 
-	private final TraversableResolver defaultTraversableResolver;
+	/**
+	 * Created lazily to avoid fishing in the classpath if one has been defined.
+	 */
+	@Lazy
+	private TraversableResolver defaultTraversableResolver;
+
 	private final ConstraintValidatorFactory defaultConstraintValidatorFactory;
 	private final ParameterNameProvider defaultParameterNameProvider;
 	private final ClockProvider defaultClockProvider;
@@ -143,7 +152,6 @@ protected AbstractConfigurationImpl(ValidationProvider<?> provider) {
 	private AbstractConfigurationImpl() {
 		this.validationBootstrapParameters = new ValidationBootstrapParameters();
 
-		this.defaultTraversableResolver = TraversableResolvers.getDefault();
 		this.defaultConstraintValidatorFactory = new ConstraintValidatorFactoryImpl();
 		this.defaultParameterNameProvider = new DefaultParameterNameProvider();
 		this.defaultClockProvider = DefaultClockProvider.INSTANCE;
@@ -566,6 +574,9 @@ public final MessageInterpolator getDefaultMessageInterpolator() {
 
 	@Override
 	public final TraversableResolver getDefaultTraversableResolver() {
+		if ( defaultTraversableResolver == null ) {
+			defaultTraversableResolver = TraversableResolvers.getDefault();
+		}
 		return defaultTraversableResolver;
 	}
 
@@ -632,7 +643,7 @@ private void parseValidationXml() {
 			LOG.ignoringXmlConfiguration();
 
 			if ( validationBootstrapParameters.getTraversableResolver() == null ) {
-				validationBootstrapParameters.setTraversableResolver( defaultTraversableResolver );
+				validationBootstrapParameters.setTraversableResolver( getDefaultTraversableResolver() );
 			}
 			if ( validationBootstrapParameters.getConstraintValidatorFactory() == null ) {
 				validationBootstrapParameters.setConstraintValidatorFactory( defaultConstraintValidatorFactory );
@@ -681,7 +692,7 @@ private void applyXmlSettings(ValidationBootstrapParameters xmlParameters) {
 				validationBootstrapParameters.setTraversableResolver( xmlParameters.getTraversableResolver() );
 			}
 			else {
-				validationBootstrapParameters.setTraversableResolver( defaultTraversableResolver );
+				validationBootstrapParameters.setTraversableResolver( getDefaultTraversableResolver() );
 			}
 		}
 

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

@@ -8,6 +8,7 @@
 
 import static org.hibernate.validator.internal.util.logging.Messages.MESSAGES;
 
+import java.util.Collections;
 import java.util.Locale;
 import java.util.Set;
 
@@ -25,6 +26,8 @@
 public class PredefinedScopeConfigurationImpl extends AbstractConfigurationImpl<PredefinedScopeHibernateValidatorConfiguration>
 		implements PredefinedScopeHibernateValidatorConfiguration, ConfigurationState {
 
+	private Set<String> builtinConstraints = Collections.emptySet();
+
 	private Set<Class<?>> beanClassesToInitialize;
 
 	public PredefinedScopeConfigurationImpl(BootstrapState state) {
@@ -35,12 +38,22 @@ public PredefinedScopeConfigurationImpl(ValidationProvider<?> validationProvider
 		super( validationProvider );
 	}
 
+	@Override
+	public PredefinedScopeHibernateValidatorConfiguration builtinConstraints(Set<String> constraints) {
+		this.builtinConstraints = CollectionHelper.toImmutableSet( constraints );
+		return thisAsT();
+	}
+
 	@Override
 	public PredefinedScopeHibernateValidatorConfiguration initializeBeanMetaData(Set<Class<?>> beanMetaDataToInitialize) {
 		beanClassesToInitialize = CollectionHelper.toImmutableSet( beanMetaDataToInitialize );
 		return thisAsT();
 	}
 
+	public Set<String> getBuiltinConstraints() {
+		return builtinConstraints;
+	}
+
 	public Set<Class<?>> getBeanClassesToInitialize() {
 		return beanClassesToInitialize;
 	}

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

@@ -132,7 +132,7 @@ public PredefinedScopeValidatorFactoryImpl(ConfigurationState configurationState
 		this.getterPropertySelectionStrategy = ValidatorFactoryConfigurationHelper.determineGetterPropertySelectionStrategy( hibernateSpecificConfig, properties, externalClassLoader );
 
 		this.valueExtractorManager = new ValueExtractorManager( configurationState.getValueExtractors() );
-		ConstraintHelper constraintHelper = new ConstraintHelper();
+		ConstraintHelper constraintHelper = ConstraintHelper.forBuiltinConstraints( hibernateSpecificConfig.getBuiltinConstraints() );
 		TypeResolutionHelper typeResolutionHelper = new TypeResolutionHelper();
 
 		ConstraintCreationContext constraintCreationContext = new ConstraintCreationContext( constraintHelper,

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

@@ -167,7 +167,7 @@ public ValidatorFactoryImpl(ConfigurationState configurationState) {
 		this.validationOrderGenerator = new ValidationOrderGenerator();
 
 		ValueExtractorManager valueExtractorManager = new ValueExtractorManager( configurationState.getValueExtractors() );
-		ConstraintHelper constraintHelper = new ConstraintHelper();
+		ConstraintHelper constraintHelper = ConstraintHelper.forAllBuiltinConstraints();
 		TypeResolutionHelper typeResolutionHelper = new TypeResolutionHelper();
 
 		this.constraintCreationContext = new ConstraintCreationContext( constraintHelper, constraintValidatorManager, typeResolutionHelper, valueExtractorManager );

engine/src/main/java/org/hibernate/validator/internal/engine/constraintvalidation/ClassBasedValidatorDescriptor.java

@@ -52,6 +52,15 @@ public static <T extends Annotation> ClassBasedValidatorDescriptor<T> of(Class<?
 		return new ClassBasedValidatorDescriptor<T>( validatorClass );
 	}
 
+	/**
+	 * Constraint checking is relaxed for built-in constraints as they have been carefully crafted so we are sure types
+	 * are right.
+	 */
+	public static <T extends Annotation> ClassBasedValidatorDescriptor<T> ofBuiltin(Class<? extends ConstraintValidator<T, ?>> validatorClass,
+			Class<? extends Annotation> registeredConstraintAnnotationType) {
+		return new ClassBasedValidatorDescriptor<T>( validatorClass );
+	}
+
 	private static EnumSet<ValidationTarget> determineValidationTargets(Class<? extends ConstraintValidator<?, ?>> validatorClass) {
 		SupportedValidationTarget supportedTargetAnnotation = validatorClass.getAnnotation(
 				SupportedValidationTarget.class );

engine/src/main/java/org/hibernate/validator/internal/engine/constraintvalidation/ConstraintValidatorDescriptor.java

@@ -49,6 +49,11 @@ static <A extends Annotation> ConstraintValidatorDescriptor<A> forClass(Class<?
 		return ClassBasedValidatorDescriptor.of( validatorClass, constraintAnnotationType );
 	}
 
+	static <A extends Annotation> ConstraintValidatorDescriptor<A> forBuiltinClass(Class<? extends ConstraintValidator<A, ?>> validatorClass,
+			Class<? extends Annotation> constraintAnnotationType) {
+		return ClassBasedValidatorDescriptor.ofBuiltin( validatorClass, constraintAnnotationType );
+	}
+
 	static <A extends Annotation, T> ConstraintValidatorDescriptor<A> forLambda(Class<A> annotationType, Type validatedType, ValidationCallable<T> lambda) {
 		return new LambdaBasedValidatorDescriptor<>( validatedType, lambda );
 	}

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

@@ -0,0 +1,139 @@
+/*
+ * 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.metadata.core;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * The list of built-in constraints.
+ * <p>
+ * We are not using the class directly to avoid loading the class if possible.
+ * <p>
+ * In the case of composing constraints, you need to define the dependencies manually.
+ * <p>
+ * When adding a new built-in constraint, please add a test in {@code MessagePropertiesTest} and
+ * {@code PredefinedScopeAllConstraintsTest}.
+ *
+ * @author Guillaume Smet
+ */
+enum BuiltinConstraint {
+
+	// Specification constraints
+	JAVAX_VALIDATION_CONSTRAINTS_ASSERT_FALSE("javax.validation.constraints.AssertFalse"),
+	JAVAX_VALIDATION_CONSTRAINTS_ASSERT_TRUE("javax.validation.constraints.AssertTrue"),
+	JAVAX_VALIDATION_CONSTRAINTS_DECIMAL_MAX("javax.validation.constraints.DecimalMax"),
+	JAVAX_VALIDATION_CONSTRAINTS_DECIMAL_MIN("javax.validation.constraints.DecimalMin"),
+	JAVAX_VALIDATION_CONSTRAINTS_DIGITS("javax.validation.constraints.Digits"),
+	JAVAX_VALIDATION_CONSTRAINTS_EMAIL("javax.validation.constraints.Email"),
+	JAVAX_VALIDATION_CONSTRAINTS_FUTURE("javax.validation.constraints.Future"),
+	JAVAX_VALIDATION_CONSTRAINTS_FUTURE_OR_PRESENT("javax.validation.constraints.FutureOrPresent"),
+	JAVAX_VALIDATION_CONSTRAINTS_MIN("javax.validation.constraints.Min"),
+	JAVAX_VALIDATION_CONSTRAINTS_MAX("javax.validation.constraints.Max"),
+	JAVAX_VALIDATION_CONSTRAINTS_NEGATIVE("javax.validation.constraints.Negative"),
+	JAVAX_VALIDATION_CONSTRAINTS_NEGATIVE_OR_ZERO("javax.validation.constraints.NegativeOrZero"),
+	JAVAX_VALIDATION_CONSTRAINTS_NOT_BLANK("javax.validation.constraints.NotBlank"),
+	JAVAX_VALIDATION_CONSTRAINTS_NOT_EMPTY("javax.validation.constraints.NotEmpty"),
+	JAVAX_VALIDATION_CONSTRAINTS_NOT_NULL("javax.validation.constraints.NotNull"),
+	JAVAX_VALIDATION_CONSTRAINTS_NULL("javax.validation.constraints.Null"),
+	JAVAX_VALIDATION_CONSTRAINTS_PAST("javax.validation.constraints.Past"),
+	JAVAX_VALIDATION_CONSTRAINTS_PAST_OR_PRESENT("javax.validation.constraints.PastOrPresent"),
+	JAVAX_VALIDATION_CONSTRAINTS_PATTERN("javax.validation.constraints.Pattern"),
+	JAVAX_VALIDATION_CONSTRAINTS_POSITIVE("javax.validation.constraints.Positive"),
+	JAVAX_VALIDATION_CONSTRAINTS_POSITIVE_OR_ZERO("javax.validation.constraints.PositiveOrZero"),
+	JAVAX_VALIDATION_CONSTRAINTS_SIZE("javax.validation.constraints.Size"),
+
+	// Hibernate Validator specific constraints
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_CODE_POINT_LENGTH("org.hibernate.validator.constraints.CodePointLength"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_CURRENCY("org.hibernate.validator.constraints.Currency"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_EMAIL("org.hibernate.validator.constraints.Email", Arrays.asList( JAVAX_VALIDATION_CONSTRAINTS_PATTERN ) ),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_ISBN("org.hibernate.validator.constraints.ISBN"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_LENGTH("org.hibernate.validator.constraints.Length"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_LUHN_CHECK("org.hibernate.validator.constraints.LuhnCheck"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_CREDIT_CARD_NUMBER("org.hibernate.validator.constraints.CreditCardNumber",
+			Arrays.asList( ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_LUHN_CHECK ) ),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_MOD10_CHECK("org.hibernate.validator.constraints.Mod10Check"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_MOD11_CHECK("org.hibernate.validator.constraints.Mod11Check"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_MOD_CHECK("org.hibernate.validator.constraints.ModCheck"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_EAN("org.hibernate.validator.constraints.EAN", Arrays.asList( ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_MOD10_CHECK ) ),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_NOT_BLANK("org.hibernate.validator.constraints.NotBlank",
+			Arrays.asList( JAVAX_VALIDATION_CONSTRAINTS_NOT_NULL ) ),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_NOT_EMPTY("org.hibernate.validator.constraints.NotEmpty",
+			Arrays.asList( JAVAX_VALIDATION_CONSTRAINTS_NOT_NULL, JAVAX_VALIDATION_CONSTRAINTS_SIZE )),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_PARAMETER_SCRIPT_ASSERT("org.hibernate.validator.constraints.ParameterScriptAssert"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_RANGE("org.hibernate.validator.constraints.Range",
+			Arrays.asList( JAVAX_VALIDATION_CONSTRAINTS_MIN, JAVAX_VALIDATION_CONSTRAINTS_MAX )),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_SAFE_HTML("org.hibernate.validator.constraints.SafeHtml"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_SCRIPT_ASSERT("org.hibernate.validator.constraints.ScriptAssert"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_URL("org.hibernate.validator.constraints.URL",
+			Arrays.asList( JAVAX_VALIDATION_CONSTRAINTS_PATTERN )),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_UNIQUE_ELEMENTS("org.hibernate.validator.constraints.UniqueElements"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_BR_CNPJ("org.hibernate.validator.constraints.br.CNPJ",
+			Arrays.asList( JAVAX_VALIDATION_CONSTRAINTS_PATTERN )),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_BR_CPF("org.hibernate.validator.constraints.br.CPF",
+			Arrays.asList( JAVAX_VALIDATION_CONSTRAINTS_PATTERN )),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_BR_TITULO_ELEITORAL("org.hibernate.validator.constraints.br.TituloEleitoral",
+			Arrays.asList( JAVAX_VALIDATION_CONSTRAINTS_PATTERN, ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_MOD11_CHECK ) ),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_PL_NIP("org.hibernate.validator.constraints.pl.NIP"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_PL_PESEL("org.hibernate.validator.constraints.pl.PESEL"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_PL_REGON("org.hibernate.validator.constraints.pl.REGON"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_TIME_DURATION_MAX("org.hibernate.validator.constraints.time.DurationMax"),
+	ORG_HIBERNATE_VALIDATOR_CONSTRAINTS_TIME_DURATION_MIN("org.hibernate.validator.constraints.time.DurationMin");
+
+	private static final Map<String, Set<BuiltinConstraint>> CONSTRAINT_MAPPING;
+
+	static {
+		CONSTRAINT_MAPPING = new HashMap<>();
+		for ( BuiltinConstraint constraint : values() ) {
+			if ( constraint.constraintDependencies.isEmpty() ) {
+				CONSTRAINT_MAPPING.put( constraint.annotationClassName, Collections.singleton( constraint ) );
+			}
+			else {
+				Set<BuiltinConstraint> constraints = new HashSet<>();
+				constraints.add( constraint );
+				constraints.addAll( constraint.constraintDependencies );
+				CONSTRAINT_MAPPING.put( constraint.annotationClassName, constraints );
+			}
+		}
+	}
+
+	private String annotationClassName;
+	private List<BuiltinConstraint> constraintDependencies;
+
+	BuiltinConstraint(String constraint) {
+		this( constraint, Collections.emptyList() );
+	}
+
+	BuiltinConstraint(String constraint, List<BuiltinConstraint> composingConstraints) {
+		this.annotationClassName = constraint;
+		this.constraintDependencies = composingConstraints;
+	}
+
+	static Set<BuiltinConstraint> resolve(Set<String> constraints) {
+		Set<BuiltinConstraint> resolvedConstraints = new HashSet<>();
+		for ( String constraint : constraints ) {
+			Set<BuiltinConstraint> builtinConstraints = CONSTRAINT_MAPPING.get( constraint );
+			if ( builtinConstraints != null ) {
+				resolvedConstraints.addAll( builtinConstraints );
+			}
+		}
+		return resolvedConstraints;
+	}
+
+	static boolean isBuiltin(String constraint) {
+		return CONSTRAINT_MAPPING.containsKey( constraint );
+	}
+
+	static Set<String> set() {
+		return CONSTRAINT_MAPPING.keySet();
+	}
+}