Introduce ConstructorValidatorFactory

src/main/java/org/unbrokendome/jackson/beanvalidation/BeanValidationModule.java

@@ -7,6 +7,7 @@
 import com.fasterxml.jackson.databind.Module;
 import com.fasterxml.jackson.databind.deser.DeserializationProblemHandler;
 
+import javax.annotation.Nullable;
 import javax.validation.ConstraintViolationException;
 import javax.validation.ValidatorFactory;
 import java.io.IOException;
@@ -17,6 +18,7 @@ public final class BeanValidationModule extends Module {
 
     private final ValidatorFactory validatorFactory;
     private final EnumSet<BeanValidationFeature> features;
+    @Nullable private ConstructorValidatorFactory constructorValidatorFactory;
 
 
     public BeanValidationModule(ValidatorFactory validatorFactory) {
@@ -58,13 +60,19 @@ public BeanValidationModule disable(BeanValidationFeature feature) {
         return this;
     }
 
+    public BeanValidationModule setConstructorValidatorFactory(@Nullable ConstructorValidatorFactory factory) {
+        this.constructorValidatorFactory = factory;
+        return this;
+    }
+
 
     @Override
     public void setupModule(SetupContext context) {
 
         BeanValidationFeatureSet featureSet = new BeanValidationFeatureSet(features);
 
-        context.addBeanDeserializerModifier(new ValidationBeanDeserializerModifier(validatorFactory, featureSet));
+        context.addBeanDeserializerModifier(new ValidationBeanDeserializerModifier(
+                validatorFactory, featureSet, constructorValidatorFactory));
 
         context.addDeserializationProblemHandler(new DeserializationProblemHandler() {
             @Override

src/main/java/org/unbrokendome/jackson/beanvalidation/ConstructorValidatorFactory.java

@@ -0,0 +1,9 @@
+package org.unbrokendome.jackson.beanvalidation;
+
+import javax.validation.Validator;
+import javax.validation.ValidatorFactory;
+import java.lang.reflect.Constructor;
+
+public interface ConstructorValidatorFactory {
+    Validator getValidator(ValidatorFactory validatorFactory, Constructor constructor, Object[] parameterValues);
+}

src/main/java/org/unbrokendome/jackson/beanvalidation/ValidatingValueInstantiator.java

@@ -16,15 +16,14 @@
 import javax.validation.ConstraintViolationException;
 import javax.validation.ElementKind;
 import javax.validation.Path;
+import javax.validation.Validator;
 import javax.validation.ValidatorFactory;
 import javax.validation.executable.ExecutableValidator;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
 import java.lang.reflect.Member;
 import java.lang.reflect.Method;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
@@ -34,16 +33,21 @@ class ValidatingValueInstantiator extends AbstractDelegatingValueInstantiator {
 
     private final ValidatorFactory validatorFactory;
     private final BeanValidationFeatureSet features;
+    private final ConstructorValidatorFactory constructorValidatorFactory;
     private boolean validationEnabled = false;
 
 
     ValidatingValueInstantiator(
             StdValueInstantiator delegate, ValidatorFactory validatorFactory,
-            BeanValidationFeatureSet features
+            BeanValidationFeatureSet features,
+            @Nullable ConstructorValidatorFactory constructorValidatorFactory
     ) {
         super(delegate);
         this.validatorFactory = validatorFactory;
         this.features = features;
+        this.constructorValidatorFactory = constructorValidatorFactory != null
+                ? constructorValidatorFactory
+                : (factory, constructor, parameterValues) -> factory.getValidator();
     }
 
 
@@ -184,21 +188,11 @@ private Set<ConstraintViolation<?>> validateCreatorArgs(
         }
 
         Member creatorMember = getWithArgsCreator().getMember();
-        ExecutableValidator executableValidator = validatorFactory.getValidator().forExecutables();
 
         if (creatorMember instanceof Constructor) {
-            Map<String, Object> hints = new HashMap<>(args.length);
             Constructor constructor = (Constructor) creatorMember;
-            Field[] declaredFields = constructor.getDeclaringClass().getDeclaredFields();
-            if (declaredFields.length >= args.length) {
-                for (int i = 0; i < args.length; i++) {
-                    hints.put(declaredFields[i].getName(), args[i]);
-                }
-            }
-            ValidationContextHolder.hints.set(hints);
-            Set violations = executableValidator.validateConstructorParameters(constructor, args);
-            ValidationContextHolder.hints.remove();
-            return violations;
+            Validator validator = constructorValidatorFactory.getValidator(validatorFactory, constructor, args);
+            return validator.forExecutables().validateConstructorParameters(constructor, args);
 
         } else if (creatorMember instanceof Method) {
             // Bean validation doesn't support parameter validation for static methods :-(

src/main/java/org/unbrokendome/jackson/beanvalidation/ValidationBeanDeserializerModifier.java

@@ -8,6 +8,7 @@
 import com.fasterxml.jackson.databind.deser.impl.MethodProperty;
 import com.fasterxml.jackson.databind.deser.std.StdValueInstantiator;
 
+import javax.annotation.Nullable;
 import javax.validation.Validator;
 import javax.validation.ValidatorFactory;
 import java.util.ArrayList;
@@ -18,11 +19,14 @@ final class ValidationBeanDeserializerModifier extends BeanDeserializerModifier
 
     private final ValidatorFactory validatorFactory;
     private final BeanValidationFeatureSet features;
+    private final ConstructorValidatorFactory constructorValidatorFactory;
 
 
-    ValidationBeanDeserializerModifier(ValidatorFactory validatorFactory, BeanValidationFeatureSet features) {
+    ValidationBeanDeserializerModifier(ValidatorFactory validatorFactory, BeanValidationFeatureSet features,
+                                       @Nullable ConstructorValidatorFactory constructorValidatorFactory) {
         this.validatorFactory = validatorFactory;
         this.features = features;
+        this.constructorValidatorFactory = constructorValidatorFactory;
     }
 
 
@@ -49,7 +53,7 @@ public BeanDeserializerBuilder updateBuilder(
         ValueInstantiator valueInstantiator = builder.getValueInstantiator();
         if (valueInstantiator instanceof StdValueInstantiator) {
             builder.setValueInstantiator(new ValidatingValueInstantiator(
-                    (StdValueInstantiator) valueInstantiator, validatorFactory, features));
+                    (StdValueInstantiator) valueInstantiator, validatorFactory, features, constructorValidatorFactory));
         }
 
         return builder;

src/test/kotlin/org/unbrokendome/jackson/beanvalidation/AbstractValidationTest.kt

@@ -9,14 +9,15 @@ import javax.validation.ConstraintViolationException
 import javax.validation.Validation
 
 
-abstract class AbstractValidationTest {
+abstract class AbstractValidationTest(constructorValidatorFactory: ConstructorValidatorFactory? = null) {
 
     private val validatorFactory = Validation.byDefaultProvider()
         .configure()
         .messageInterpolator(ParameterMessageInterpolator())
         .buildValidatorFactory()
 
     protected val beanValidationModule: BeanValidationModule = BeanValidationModule(validatorFactory)
+        .setConstructorValidatorFactory(constructorValidatorFactory)
 
     protected val objectMapper: ObjectMapper = ObjectMapper()
         .registerModule(beanValidationModule)

src/test/kotlin/org/unbrokendome/jackson/beanvalidation/constraints/HibernateConstructorValidatorFactory.kt

@@ -0,0 +1,19 @@
+package org.unbrokendome.jackson.beanvalidation.constraints
+
+import org.hibernate.validator.HibernateValidatorFactory
+import org.unbrokendome.jackson.beanvalidation.ConstructorValidatorFactory
+import java.lang.reflect.Constructor
+import javax.validation.Validator
+import javax.validation.ValidatorFactory
+
+class HibernateConstructorValidatorFactory : ConstructorValidatorFactory {
+    override fun getValidator(validatorFactory: ValidatorFactory, constructor: Constructor<Any>, parameterValues: Array<out Any>): Validator {
+        val declaredFields = constructor.declaringClass.declaredFields
+        val payload: Map<String, Any> = parameterValues
+            .mapIndexed { index, value -> declaredFields[index].name to value}
+            .toMap()
+
+        return validatorFactory.unwrap(HibernateValidatorFactory::class.java)
+            .usingContext().constraintValidatorPayload(payload).validator
+    }
+}