Java 类javax.validation.ParameterNameProvider 实例源码

/**
 * 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);
}

/**
 * Creates a new {@code BeanMetaDataManager}.
 *
 * @param constraintHelper
 *            the constraint helper
 * @param executableHelper
 *            the executable helper
 * @param parameterNameProvider
 *            the parameter name provider
 * @param optionalMetaDataProviders
 *            optional meta data provider used on top of the annotation
 *            based provider
 */
public BeanMetaDataManager513(ConstraintHelper constraintHelper, ExecutableHelper executableHelper,
        ParameterNameProvider parameterNameProvider, List<MetaDataProvider> optionalMetaDataProviders) {
    super(constraintHelper, executableHelper, parameterNameProvider, optionalMetaDataProviders);
    this.constraintHelper = constraintHelper;
    this.metaDataProviders = newArrayList();
    this.metaDataProviders.addAll(optionalMetaDataProviders);
    this.executableHelper = executableHelper;

    this.beanMetaDataCache = new ConcurrentReferenceHashMap<Class<?>, BeanMetaData<?>>(DEFAULT_INITIAL_CAPACITY,
            DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL, SOFT, SOFT, EnumSet.of(IDENTITY_COMPARISONS));

    AnnotationProcessingOptions annotationProcessingOptions = getAnnotationProcessingOptionsFromNonDefaultProviders();
    AnnotationMetaDataProvider defaultProvider = new AnnotationMetaDataProvider(constraintHelper,
            parameterNameProvider, annotationProcessingOptions);
    this.metaDataProviders.add(defaultProvider);
}

@Override
public ValidatorContext parameterNameProvider(
    final ParameterNameProvider pparameterNameProvider) {
  if (pparameterNameProvider == null) {
    this.parameterNameProviderEntry = this.factoryParameterNameProvider;
  } else {
    this.parameterNameProviderEntry = pparameterNameProvider;
  }
  return this;
}

private List<MetaDataProvider> buildDataProviders(ParameterNameProvider parameterNameProvider) {
    List<MetaDataProvider> metaDataProviders = newArrayList();
    if (xmlMetaDataProvider != null) {
        metaDataProviders.add(xmlMetaDataProvider);
    }

    if (!constraintMappings.isEmpty()) {
        metaDataProviders.add(new ProgrammaticMetaDataProvider513(constraintHelper, parameterNameProvider,
                constraintMappings));
    }
    return metaDataProviders;
}

@Override
public ParameterNameProvider getParameterNameProvider() {
    throw new UnsupportedOperationException();
}

@Override
public ParameterNameProvider getDefaultParameterNameProvider() {
    throw new UnsupportedOperationException();
}

@Override
public ParameterNameProvider getParameterNameProvider() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public ParameterNameProvider getParameterNameProvider() {
    return this.paramNameProv;
}

public void setParameterNameProvider(ParameterNameProvider paramNameProv) {
    this.paramNameProv = paramNameProv;
}

@Override
public ParameterNameProvider getParameterNameProvider() {
  return null;
}

/**
 * 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 ParameterNameProvider getParameterNameProvider() {
  return this.parameterNameProvider;
}

@Override
public AbstractBaseGwtConfiguration parameterNameProvider(
    final ParameterNameProvider pparameterNameProvider) {
  throw new UnsupportedOperationException("GWT does not support xml configuration");
}

@Override
public ParameterNameProvider getDefaultParameterNameProvider() {
  throw new UnsupportedOperationException("GWT does not support xml configuration");
}

@Override
public ParameterNameProvider getParameterNameProvider() {
  return this.parameterNameProvider;
}

public ValidatorFactoryImpl513(ConfigurationState configurationState) {
    this.messageInterpolator = configurationState.getMessageInterpolator();
    this.traversableResolver = configurationState.getTraversableResolver();
    this.parameterNameProvider = configurationState.getParameterNameProvider();
    this.beanMetaDataManagerMap = Collections
            .synchronizedMap(new IdentityHashMap<ParameterNameProvider, BeanMetaDataManager513>());
    this.constraintHelper = new ConstraintHelper();
    this.typeResolutionHelper = new TypeResolutionHelper();
    this.executableHelper = new ExecutableHelper(typeResolutionHelper);

    // HV-302; don't load XmlMappingParser if not necessary
    if (configurationState.getMappingStreams().isEmpty()) {
        this.xmlMetaDataProvider = null;
    } else {
        this.xmlMetaDataProvider = new XmlMetaDataProvider(constraintHelper, parameterNameProvider,
                configurationState.getMappingStreams());
    }

    Map<String, String> properties = configurationState.getProperties();

    boolean tmpFailFast = false;
    List<ValidatedValueUnwrapper<?>> tmpValidatedValueHandlers = newArrayList(5);
    Set<DefaultConstraintMapping> tmpConstraintMappings = newHashSet();

    if (configurationState instanceof ConfigurationImpl) {
        ConfigurationImpl hibernateSpecificConfig = (ConfigurationImpl) configurationState;

        if (hibernateSpecificConfig.getProgrammaticMappings().size() > 0) {
            tmpConstraintMappings.addAll(hibernateSpecificConfig.getProgrammaticMappings());
        }
        // check whether fail fast is programmatically enabled
        tmpFailFast = hibernateSpecificConfig.getFailFast();

        tmpValidatedValueHandlers.addAll(hibernateSpecificConfig.getValidatedValueHandlers());

    }
    this.constraintMappings = Collections.unmodifiableSet(tmpConstraintMappings);

    tmpFailFast = checkPropertiesForFailFast(properties, tmpFailFast);
    this.failFast = tmpFailFast;

    tmpValidatedValueHandlers.addAll(getPropertyConfiguredValidatedValueHandlers(properties));
    this.validatedValueHandlers = Collections.unmodifiableList(tmpValidatedValueHandlers);

    this.constraintValidatorManager = new ConstraintValidatorManager(
            configurationState.getConstraintValidatorFactory());
}

@Override
public ParameterNameProvider getParameterNameProvider() {
    return parameterNameProvider;
}

public ProgrammaticMetaDataProvider513(ConstraintHelper constraintHelper,
        ParameterNameProvider parameterNameProvider, Set<DefaultConstraintMapping> constraintMappings) {
    super(constraintHelper, parameterNameProvider, constraintMappings);
}

/**
 * {@inheritDoc}
 */
public ParameterNameProvider getParameterNameProvider()
{
   return validatorFactory.getParameterNameProvider();
}

/**
 * {@inheritDoc}
 */
public ParameterNameProvider getParameterNameProvider()
{
   return validatorFactory.getParameterNameProvider();
}

@Override
public ParameterNameProvider getParameterNameProvider() {
    return factory().getParameterNameProvider();
}

@Override
public ParameterNameProvider getParameterNameProvider() {
    return factory().getParameterNameProvider();
}

@Override
public ParameterNameProvider getDefaultParameterNameProvider() {
    return delegate.getDefaultParameterNameProvider();
}

@Override
public ParameterNameProvider getParameterNameProvider() {
    return delegate().getParameterNameProvider();
}

@Override
public ParameterNameProvider getParameterNameProvider() {
    return new DefaultParameterNameProvider();
}

/**
 * Returns the parameter name provider for this configuration.
 * <p/>
 * {@link ParameterNameProvider} is defined in the following decreasing priority:
 * <ul>
 * <li>set via the {@link Configuration} programmatic API</li>
 * <li>defined in {@code META-INF/validation.xml} provided that {@code ignoreXmlConfiguration} is
 * {@code false}. In this case the instance is created via its no-arg constructor.</li>
 * <li>{@code null} if undefined.</li>
 * </ul>
 *
 * @return parameter name provider instance or {@code null} if not defined
 *
 * @since 1.1
 */
ParameterNameProvider getParameterNameProvider();