Java 类javax.validation.ConstraintValidatorFactory 实例源码

/**
 * create validator
 * 
 * @param constraintValidatorFactory
 * @param messageInterpolator
 * @param traversableResolver
 * @param parameterNameProvider
 * @param failFast
 * @param validatedValueHandlers
 * @return
 */
protected Validator createValidator(ConstraintValidatorFactory constraintValidatorFactory,
        MessageInterpolator messageInterpolator, TraversableResolver traversableResolver,
        ParameterNameProvider parameterNameProvider, boolean failFast,
        List<ValidatedValueUnwrapper<?>> validatedValueHandlers) {
    BeanMetaDataManager513 beanMetaDataManager;
    if (!beanMetaDataManagerMap.containsKey(parameterNameProvider)) {
        beanMetaDataManager = new BeanMetaDataManager513(constraintHelper, executableHelper, parameterNameProvider,
                buildDataProviders(parameterNameProvider));
        beanMetaDataManagerMap.put(parameterNameProvider, beanMetaDataManager);
    } else {
        beanMetaDataManager = beanMetaDataManagerMap.get(parameterNameProvider);
    }

    return new ValidatorImpl(constraintValidatorFactory, messageInterpolator, traversableResolver,
            beanMetaDataManager, parameterNameProvider, typeResolutionHelper, validatedValueHandlers,
            constraintValidatorManager, failFast);
}

public static ValidatorFactory buildValidatorFactory(boolean osgi,
                                                     ValidationProviderResolver validationProviderResolver,
                                                     MessageInterpolator messageInterpolator,
                                                     TraversableResolver traversableResolver,
                                                     ConstraintValidatorFactory constraintValidatorFactory) {

    ValidationProviderResolver resolvedValidationProviderResolver =
            resolveValidationProviderResolver(osgi, validationProviderResolver);

    GenericBootstrap bootstrap = Validation.byDefaultProvider();
    if (resolvedValidationProviderResolver != null) {
        bootstrap.providerResolver(resolvedValidationProviderResolver);
    }
    Configuration<?> configuration = bootstrap.configure();

    if (messageInterpolator != null) {
        configuration.messageInterpolator(messageInterpolator);
    }

    if (traversableResolver != null) {
        configuration.traversableResolver(traversableResolver);
    }

    if (constraintValidatorFactory != null) {
        configuration.constraintValidatorFactory(constraintValidatorFactory);
    }

    return configuration.buildValidatorFactory();
}

@Provides
@Singleton
ValidatorFactory validatorFactory(ConstraintValidatorFactory constraintValidatorFactory) {
  ClassLoader tccl = Thread.currentThread().getContextClassLoader();
  try {
    Thread.currentThread().setContextClassLoader(HibernateValidator.class.getClassLoader());

    ValidatorFactory factory = Validation.byDefaultProvider().configure()
        .constraintValidatorFactory(constraintValidatorFactory)
        .parameterNameProvider(new AopAwareParanamerParameterNameProvider())
        .traversableResolver(new AlwaysTraversableResolver())
        .buildValidatorFactory();

    // FIXME: Install custom MessageInterpolator that can properly find/merge ValidationMessages.properties for bundles

    // exercise interpolator to preload elements (avoids issues later when TCCL might be different)
    factory.getValidator().validate(new Object()
    {
      // minimal token message
      @NotNull(message = "${0}")
      String empty;
    });

    return factory;
  }
  finally {
    Thread.currentThread().setContextClassLoader(tccl);
  }
}

@Override
public ValidatorContext constraintValidatorFactory(
    final ConstraintValidatorFactory constraintValidatorfactory) {
  if (constraintValidatorfactory == null) {
    this.constraintValidatorfactoryEntry = this.factoryConstraintValidatorfactory;
  } else {
    this.constraintValidatorfactoryEntry = constraintValidatorfactory;
  }
  return this;
}

@Override
public boolean isValid(List<?> entries,
        ConstraintValidatorContext context) {
    boolean valid = true;

    if(entries == null){
        return valid;
    }

    if(ArrayUtils.getLength(constraints) != ArrayUtils.getLength(messages)){
        throw new ConstraintDeclarationException("Number of messages must be the same as number of constraints");
    }

    ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();
    ConstraintValidatorFactory constraintValidatorFactory = validatorFactory.getConstraintValidatorFactory();

    for(Object element : entries) {
        for(Class<?> constraint : constraints) {
            Constraint constraintAnnotation = constraint.getAnnotation(Constraint.class);
            Class<? extends ConstraintValidator<?, ?>>[] constraintValidators = constraintAnnotation.validatedBy();
            for (int i = 0; i < constraintValidators.length; i++) {
                ConstraintValidator constraintValidator = constraintValidatorFactory.getInstance(constraintValidators[i]);
                if(!constraintValidator.isValid(element, context)){
                    context.buildConstraintViolationWithTemplate(messages[i]).addConstraintViolation().disableDefaultConstraintViolation();
                    valid = false;
                }
            }
        }

    }

    return valid;
}

@Override
public void afterPropertiesSet() {
    @SuppressWarnings({"rawtypes", "unchecked"})
    Configuration<?> configuration = (this.providerClass != null ?
            Validation.byProvider(this.providerClass).configure() :
            Validation.byDefaultProvider().configure());

    MessageInterpolator targetInterpolator = this.messageInterpolator;
    if (targetInterpolator == null) {
        targetInterpolator = configuration.getDefaultMessageInterpolator();
    }
    configuration.messageInterpolator(new LocaleContextMessageInterpolator(targetInterpolator));

    if (this.traversableResolver != null) {
        configuration.traversableResolver(this.traversableResolver);
    }

    ConstraintValidatorFactory targetConstraintValidatorFactory = this.constraintValidatorFactory;
    if (targetConstraintValidatorFactory == null && this.applicationContext != null) {
        targetConstraintValidatorFactory =
                new SpringConstraintValidatorFactory(this.applicationContext.getAutowireCapableBeanFactory());
    }
    if (targetConstraintValidatorFactory != null) {
        configuration.constraintValidatorFactory(targetConstraintValidatorFactory);
    }

    if (this.parameterNameDiscoverer != null) {
        configureParameterNameProviderIfPossible(configuration);
    }

    if (this.mappingLocations != null) {
        for (Resource location : this.mappingLocations) {
            try {
                configuration.addMapping(location.getInputStream());
            }
            catch (IOException ex) {
                throw new IllegalStateException("Cannot read mapping resource: " + location);
            }
        }
    }

    for (Map.Entry<String, String> entry : this.validationPropertyMap.entrySet()) {
        configuration.addProperty(entry.getKey(), entry.getValue());
    }

    // Allow for custom post-processing before we actually build the ValidatorFactory.
    postProcessConfiguration(configuration);

    this.validatorFactory = configuration.buildValidatorFactory();
    setTargetValidator(this.validatorFactory.getValidator());
}

@Override
public ConstraintValidatorFactory getConstraintValidatorFactory() {
    Assert.notNull(this.validatorFactory, "No target ValidatorFactory set");
    return this.validatorFactory.getConstraintValidatorFactory();
}

@Override
public MinijaxValidatorContext constraintValidatorFactory(final ConstraintValidatorFactory factory) {
    return this;
}

@Override
public ConstraintValidatorFactory getConstraintValidatorFactory() {
    throw new UnsupportedOperationException();
}

@Override
public ConstraintValidatorFactory getDefaultConstraintValidatorFactory() {
    throw new UnsupportedOperationException();
}

@Override
public ConstraintValidatorFactory getConstraintValidatorFactory() {
    Assert.notNull(this.validatorFactory, "No target ValidatorFactory set");
    return this.validatorFactory.getConstraintValidatorFactory();
}

@Override
public void afterPropertiesSet() {
    @SuppressWarnings({"rawtypes", "unchecked"})
    Configuration<?> configuration = (this.providerClass != null ?
            Validation.byProvider(this.providerClass).configure() :
            Validation.byDefaultProvider().configure());

    MessageInterpolator targetInterpolator = this.messageInterpolator;
    if (targetInterpolator == null) {
        targetInterpolator = configuration.getDefaultMessageInterpolator();
    }
    configuration.messageInterpolator(new LocaleContextMessageInterpolator(targetInterpolator));

    if (this.traversableResolver != null) {
        configuration.traversableResolver(this.traversableResolver);
    }

    ConstraintValidatorFactory targetConstraintValidatorFactory = this.constraintValidatorFactory;
    if (targetConstraintValidatorFactory == null && this.applicationContext != null) {
        targetConstraintValidatorFactory =
                new SpringConstraintValidatorFactory(this.applicationContext.getAutowireCapableBeanFactory());
    }
    if (targetConstraintValidatorFactory != null) {
        configuration.constraintValidatorFactory(targetConstraintValidatorFactory);
    }

    if (this.parameterNameDiscoverer != null) {
        configureParameterNameProviderIfPossible(configuration);
    }

    if (this.mappingLocations != null) {
        for (Resource location : this.mappingLocations) {
            try {
                configuration.addMapping(location.getInputStream());
            }
            catch (IOException ex) {
                throw new IllegalStateException("Cannot read mapping resource: " + location);
            }
        }
    }

    for (Map.Entry<String, String> entry : this.validationPropertyMap.entrySet()) {
        configuration.addProperty(entry.getKey(), entry.getValue());
    }

    // Allow for custom post-processing before we actually build the ValidatorFactory.
    postProcessConfiguration(configuration);

    this.validatorFactory = configuration.buildValidatorFactory();
    setTargetValidator(this.validatorFactory.getValidator());
}

@Override
public ConstraintValidatorFactory getConstraintValidatorFactory() {
    Assert.notNull(this.validatorFactory, "No target ValidatorFactory set");
    return this.validatorFactory.getConstraintValidatorFactory();
}

@Override
public ConstraintValidatorFactory getConstraintValidatorFactory() {
    Assert.notNull(this.validatorFactory, "No target ValidatorFactory set");
    return this.validatorFactory.getConstraintValidatorFactory();
}

public ConstraintValidatorFactory getConstraintValidatorFactory() {
    return constraintValidatorFactory;
}

/**
 * To use a custom {@link ConstraintValidatorFactory}
 */
public void setConstraintValidatorFactory(ConstraintValidatorFactory constraintValidatorFactory) {
    this.constraintValidatorFactory = constraintValidatorFactory;
}

@Override
protected void configure() {
  final MethodInterceptor interceptor = new ValidationInterceptor();
  bindInterceptor(Matchers.any(), Matchers.annotatedWith(Validate.class), interceptor);
  requestInjection(interceptor);
  bind(ConstraintValidatorFactory.class).to(GuiceConstraintValidatorFactory.class);
}

/**
 * constructor.
 */
public AbstractBaseConfigurationState(final ConstraintValidatorFactory constraintValidatorFactory,
    final MessageInterpolator messageInterpolator, final Map<String, String> properties,
    final TraversableResolver traversableResolver) {
  this.constraintValidatorFactory = constraintValidatorFactory;
  this.messageInterpolator = messageInterpolator;
  this.properties = Collections.unmodifiableMap(properties);
  this.traversableResolver = traversableResolver;
}

@Override
public ConstraintValidatorFactory getConstraintValidatorFactory() {
  return this.constraintValidatorFactory;
}

public GwtConfigurationState(final ConstraintValidatorFactory constraintValidatorFactory,
    final MessageInterpolator messageInterpolator, final Map<String, String> properties,
    final TraversableResolver traversableResolver) {
  super(constraintValidatorFactory, messageInterpolator, properties, traversableResolver);
}

/**
 * Always throws {@link UnsupportedOperationException}.
 *
 * @throws UnsupportedOperationException unsupported on gwt
 */
@Override
public <T extends ConstraintValidator<?, ?>> T getInstance(final Class<T> key) {
  throw new UnsupportedOperationException("GWT does not support "
      + ConstraintValidatorFactory.class.getName() + " use GWT.create instead");
}

/**
 * initialize values.
 *
 * @param factory constraint validator factory to set
 * @param messageInterpolator message interpolator to set
 * @param traversableResolver traversable resolver to set
 * @param pparameterNameProvider parameter resolver to set
 */
public void init(final ConstraintValidatorFactory factory,
    final MessageInterpolator messageInterpolator, final TraversableResolver traversableResolver,
    final ParameterNameProvider pparameterNameProvider) {
  this.contraintValidatorFactory = factory;
  this.messageInterpolator = messageInterpolator;
  this.traversableResolver = traversableResolver;
  this.parameterNameProvider = pparameterNameProvider;
}

protected ConstraintValidatorFactory getConstraintValidatorFactory() {
  return this.contraintValidatorFactory;
}

@Override
public final ConstraintValidatorFactory getDefaultConstraintValidatorFactory() {
  return GWT.create(ConstraintValidatorFactory.class);
}

/**
 * GWT does not support {@link ConstraintValidatorFactory}, so the object returned by this method
 * will not work.
 */
@Override
public final ConstraintValidatorFactory getConstraintValidatorFactory() {
  return this.constraintValidatorFactory;
}

/**
 * initialize factory.
 *
 * @param configState ConfigurationState
 */
public final void init(final ConfigurationState configState) {
  final ConstraintValidatorFactory configConstraintValidatorFactory =
      configState.getConstraintValidatorFactory();
  this.constraintValidatorFactory = configConstraintValidatorFactory == null
      ? GWT.<ConstraintValidatorFactory>create(ConstraintValidatorFactory.class)
      : configConstraintValidatorFactory;
  final TraversableResolver configTraversableResolver = configState.getTraversableResolver();
  this.traversableResolver = configTraversableResolver == null ? new DefaultTraversableResolver()
      : configTraversableResolver;
  final MessageInterpolator configMessageInterpolator = configState.getMessageInterpolator();
  this.messageInterpolator = configMessageInterpolator == null ? new GwtMessageInterpolator()
      : configMessageInterpolator;
  this.parameterNameProvider = configState.getParameterNameProvider();
}

public GwtConfigurationState(final ConstraintValidatorFactory pconstraintValidatorFactory,
    final MessageInterpolator pmessageInterpolator, final Map<String, String> pproperties,
    final TraversableResolver ptraversableResolver) {
  super(pconstraintValidatorFactory, pmessageInterpolator, pproperties, ptraversableResolver);
}

public GwtConfigurationState(final ConstraintValidatorFactory pconstraintValidatorFactory,
    final MessageInterpolator pmessageInterpolator, final Map<String, String> pproperties,
    final TraversableResolver ptraversableResolver) {
  super(pconstraintValidatorFactory, pmessageInterpolator, pproperties, ptraversableResolver);
}

@Override
public ConstraintValidatorFactory getConstraintValidatorFactory() {
    return constraintValidatorManager.getDefaultConstraintValidatorFactory();
}

@Override
public HibernateValidatorContext constraintValidatorFactory(ConstraintValidatorFactory factory) {
    if (factory == null) {
        this.constraintValidatorFactory = validatorFactory.getConstraintValidatorFactory();
    } else {
        this.constraintValidatorFactory = factory;
    }
    return this;
}

@SuppressWarnings("unchecked")
public void afterPropertiesSet() {
    @SuppressWarnings("rawtypes")
    Configuration configuration = (this.providerClass != null ?
            Validation.byProvider(this.providerClass).configure() :
            Validation.byDefaultProvider().configure());

    MessageInterpolator targetInterpolator = this.messageInterpolator;
    if (targetInterpolator == null) {
        targetInterpolator = configuration.getDefaultMessageInterpolator();
    }
    configuration.messageInterpolator(new LocaleContextMessageInterpolator(targetInterpolator));

    if (this.traversableResolver != null) {
        configuration.traversableResolver(this.traversableResolver);
    }

    ConstraintValidatorFactory targetConstraintValidatorFactory = this.constraintValidatorFactory;
    if (targetConstraintValidatorFactory == null && this.applicationContext != null) {
        targetConstraintValidatorFactory =
                new SpringConstraintValidatorFactory(this.applicationContext.getAutowireCapableBeanFactory());
    }
    if (targetConstraintValidatorFactory != null) {
        configuration.constraintValidatorFactory(targetConstraintValidatorFactory);
    }

    if (this.mappingLocations != null) {
        for (Resource location : this.mappingLocations) {
            try {
                configuration.addMapping(location.getInputStream());
            }
            catch (IOException ex) {
                throw new IllegalStateException("Cannot read mapping resource: " + location);
            }
        }
    }

    for (Map.Entry<String, String> entry : this.validationPropertyMap.entrySet()) {
        configuration.addProperty(entry.getKey(), entry.getValue());
    }

    // Allow for custom post-processing before we actually build the ValidatorFactory.
    postProcessConfiguration(configuration);

    this.validatorFactory = configuration.buildValidatorFactory();
    setTargetValidator(this.validatorFactory.getValidator());
}

public ConstraintValidatorFactory getConstraintValidatorFactory() {
    return this.validatorFactory.getConstraintValidatorFactory();
}

/**
 * {@inheritDoc}
 */
public ConstraintValidatorFactory getConstraintValidatorFactory()
{
   return validatorFactory.getConstraintValidatorFactory();
}

/**
 * {@inheritDoc}
 */
public ConstraintValidatorFactory getConstraintValidatorFactory()
{
   return validatorFactory.getConstraintValidatorFactory();
}

@Override
public ConstraintValidatorFactory getConstraintValidatorFactory() {
    return factory().getConstraintValidatorFactory();
}

@Override
public ConstraintValidatorFactory getConstraintValidatorFactory() {
    return factory().getConstraintValidatorFactory();
}

@Override
public ConstraintValidatorFactory getDefaultConstraintValidatorFactory() {
    return delegate.getDefaultConstraintValidatorFactory();
}

@Override
public ConstraintValidatorFactory getConstraintValidatorFactory() {
    return delegate().getConstraintValidatorFactory();
}

@Override
public ConstraintValidatorFactory getDefaultConstraintValidatorFactory() {
    return null;
}

@Override
public ConstraintValidatorFactory getConstraintValidatorFactory() {
    return null;
}