bval-jsr/src/main/java/org/apache/bval/jsr/ConfigurationImpl.java - bval - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.bval.jsr;

 import java.io.Closeable;
 import java.io.InputStream;
 import java.time.Clock;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Supplier;

 import javax.validation.BootstrapConfiguration;
 import javax.validation.ClockProvider;
 import javax.validation.ConstraintValidatorFactory;
 import javax.validation.MessageInterpolator;
 import javax.validation.ParameterNameProvider;
 import javax.validation.TraversableResolver;
 import javax.validation.ValidationException;
 import javax.validation.ValidationProviderResolver;
 import javax.validation.ValidatorFactory;
 import javax.validation.spi.BootstrapState;
 import javax.validation.spi.ConfigurationState;
 import javax.validation.spi.ValidationProvider;
 import javax.validation.valueextraction.ValueExtractor;

 import org.apache.bval.jsr.parameter.DefaultParameterNameProvider;
 import org.apache.bval.jsr.resolver.DefaultTraversableResolver;
 import org.apache.bval.jsr.util.IOs;
 import org.apache.bval.jsr.valueextraction.ValueExtractors;
 import org.apache.bval.jsr.xml.ValidationParser;
 import org.apache.bval.util.CloseableAble;
 import org.apache.bval.util.Exceptions;
 import org.apache.bval.util.Lazy;
 import org.apache.bval.util.reflection.Reflection;
 import org.apache.commons.weaver.privilizer.Privileged;

 /**
  * Description: used to configure apache-validation for jsr.
  * Implementation of Configuration that also implements ConfigurationState,
  * hence this can be passed to buildValidatorFactory(ConfigurationState).
  * <br/>
  */
 public class ConfigurationImpl implements ApacheValidatorConfiguration, ConfigurationState, CloseableAble {

     private class LazyParticipant<T> extends Lazy<T> {
         private boolean locked;

         private LazyParticipant(Supplier<T> init) {
             super(init);
         }

         ConfigurationImpl override(T value) {
             if (value != null) {
                 synchronized (this) {
                     if (!locked) {
                         try {
                             reset(() -> value);
                         } finally {
                             ConfigurationImpl.this.prepared = false;
                         }
                     }
                 }
             }
             return ConfigurationImpl.this;
         }

         synchronized ConfigurationImpl externalOverride(T value) {
             locked = false;
             try {
                 return override(value);
             } finally {
                 locked = true;
             }
         }
     }

     /**
      * Configured {@link ValidationProvider}
      */
     //couldn't this be parameterized <ApacheValidatorConfiguration> or <? super ApacheValidatorConfiguration>?
     private final ValidationProvider<ApacheValidatorConfiguration> provider;

     /**
      * Configured {@link ValidationProviderResolver}
      */
     private final ValidationProviderResolver providerResolver;

     /**
      * Configured {@link ValidationProvider} class
      */
     private Class<? extends ValidationProvider<?>> providerClass;

     private final MessageInterpolator defaultMessageInterpolator = new DefaultMessageInterpolator();

     private final LazyParticipant<MessageInterpolator> messageInterpolator =
         new LazyParticipant<>(this::getDefaultMessageInterpolator);

     private final ConstraintValidatorFactory defaultConstraintValidatorFactory =
         new DefaultConstraintValidatorFactory();

     private final LazyParticipant<ConstraintValidatorFactory> constraintValidatorFactory =
         new LazyParticipant<>(this::getDefaultConstraintValidatorFactory);

     private final TraversableResolver defaultTraversableResolver = new DefaultTraversableResolver();

     private final LazyParticipant<TraversableResolver> traversableResolver =
         new LazyParticipant<>(this::getDefaultTraversableResolver);

     private final ParameterNameProvider defaultParameterNameProvider = new DefaultParameterNameProvider();

     private final LazyParticipant<ParameterNameProvider> parameterNameProvider =
         new LazyParticipant<>(this::getDefaultParameterNameProvider);

     private final ClockProvider defaultClockProvider = Clock::systemDefaultZone;

     private final LazyParticipant<ClockProvider> clockProvider = new LazyParticipant<>(this::getDefaultClockProvider);

     private final ValueExtractors bootstrapValueExtractors = ValueExtractors.EMPTY.createChild();
     private final ValueExtractors valueExtractors = bootstrapValueExtractors.createChild();

     private final Lazy<BootstrapConfiguration> bootstrapConfiguration = new Lazy<>(this::createBootstrapConfiguration);

     private final Set<InputStream> mappingStreams = new HashSet<>();
     private final Map<String, String> properties = new HashMap<>();

     private boolean beforeCdi = false;
     private ClassLoader loader;

     // BEGIN DEFAULTS
     /**
      * false = dirty flag (to prevent from multiple parsing validation.xml)
      */
     private boolean prepared = false;
     // END DEFAULTS

     private boolean ignoreXmlConfiguration = false;

     private ParticipantFactory participantFactory;
     private ValidationParser validationParser;

     /**
      * Create a new ConfigurationImpl instance.
      * @param aState bootstrap state
      * @param aProvider provider
      */
     public ConfigurationImpl(BootstrapState aState, ValidationProvider<ApacheValidatorConfiguration> aProvider) {
         Exceptions.raiseIf(aProvider == null && aState == null, ValidationException::new,
             "one of provider or state is required");

         if (aProvider == null) {
             this.provider = null;
             if (aState.getValidationProviderResolver() == null) {
                 providerResolver = aState.getDefaultValidationProviderResolver();
             } else {
                 providerResolver = aState.getValidationProviderResolver();
             }
         } else {
             this.provider = aProvider;
             this.providerResolver = null;
         }
     }

     /**
      * {@inheritDoc}
      * Ignore data from the <i>META-INF/validation.xml</i> file if this
      * method is called.
      *
      * @return this
      */
     @Override
     public ApacheValidatorConfiguration ignoreXmlConfiguration() {
         ignoreXmlConfiguration = true;
         return this;
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public ConfigurationImpl messageInterpolator(MessageInterpolator resolver) {
         return messageInterpolator.externalOverride(resolver);
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public ApacheValidatorConfiguration traversableResolver(TraversableResolver resolver) {
         return traversableResolver.externalOverride(resolver);
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public ConfigurationImpl constraintValidatorFactory(ConstraintValidatorFactory constraintValidatorFactory) {
         return this.constraintValidatorFactory.externalOverride(constraintValidatorFactory);
     }

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

     @Override
     public ApacheValidatorConfiguration clockProvider(ClockProvider clockProvider) {
         return this.clockProvider.externalOverride(clockProvider);
     }

     /**
      * {@inheritDoc}
      * Add a stream describing constraint mapping in the Bean Validation
      * XML format.
      *
      * @return this
      */
     @Override
     public ApacheValidatorConfiguration addMapping(InputStream stream) {
         if (stream != null) {
             mappingStreams.add(IOs.convertToMarkableInputStream(stream));
         }
         return this;
     }

     /**
      * {@inheritDoc}
      * Add a provider specific property. This property is equivalent to
      * XML configuration properties.
      * If we do not know how to handle the property, we silently ignore it.
      *
      * @return this
      */
     @Override
     public ApacheValidatorConfiguration addProperty(String name, String value) {
         properties.put(name, value);
         return this;
     }

     @Override
     public MessageInterpolator getDefaultMessageInterpolator() {
         return defaultMessageInterpolator;
     }

     @Override
     public TraversableResolver getDefaultTraversableResolver() {
         return defaultTraversableResolver;
     }

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

     @Override
     public ParameterNameProvider getDefaultParameterNameProvider() {
         return defaultParameterNameProvider;
     }

     @Override
     public ClockProvider getDefaultClockProvider() {
         return defaultClockProvider;
     }

     /**
      * {@inheritDoc}
      * Return a map of non type-safe custom properties.
      *
      * @return null
      */
     @Override
     public Map<String, String> getProperties() {
         return properties;
     }

     /**
      * {@inheritDoc}
      * Returns true if Configuration.ignoreXMLConfiguration() has been called.
      * In this case, we ignore META-INF/validation.xml
      *
      * @return true
      */
     @Override
     public boolean isIgnoreXmlConfiguration() {
         return ignoreXmlConfiguration;
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public Set<InputStream> getMappingStreams() {
         return mappingStreams;
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public MessageInterpolator getMessageInterpolator() {
         return messageInterpolator.get();
     }

     @Override
     public BootstrapConfiguration getBootstrapConfiguration() {
         return bootstrapConfiguration.get();
     }

     /**
      * {@inheritDoc}
      * main factory method to build a ValidatorFactory
      *
      * @throws ValidationException if the ValidatorFactory cannot be built
      */
     @Override
     public ValidatorFactory buildValidatorFactory() {
         return doBuildValidatorFactory();
     }

     /**
      * {@inheritDoc}
      * @return the constraint validator factory of this configuration.
      */
     @Override
     public ConstraintValidatorFactory getConstraintValidatorFactory() {
         return constraintValidatorFactory.get();
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public TraversableResolver getTraversableResolver() {
         return traversableResolver.get();
     }

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

     @Override
     public ClockProvider getClockProvider() {
         return clockProvider.get();
     }

     @Override
     public ApacheValidatorConfiguration addValueExtractor(ValueExtractor<?> extractor) {
         valueExtractors.add(extractor);
         return this;
     }

     @Override
     public Set<ValueExtractor<?>> getValueExtractors() {
         return Collections.unmodifiableSet(new LinkedHashSet<>(valueExtractors.getValueExtractors().values()));
     }

     public void deferBootstrapOverrides() {
         beforeCdi = true;
     }

     public void releaseDeferredBootstrapOverrides() {
         if (beforeCdi) {
             beforeCdi = false;
             performBootstrapOverrides();
         }
     }

     @Override
     public Closeable getCloseable() {
         if (participantFactory == null) {
             return () -> {
             };
         }
         return participantFactory;
     }

     @Privileged
     private ValidatorFactory doBuildValidatorFactory() {
         prepare();
         return Optional.<ValidationProvider<?>> ofNullable(provider).orElseGet(this::findProvider)
             .buildValidatorFactory(this);
     }

     private void prepare() {
         if (!prepared) {
             applyBootstrapConfiguration();
             prepared = true;
         }
     }

     private BootstrapConfiguration createBootstrapConfiguration() {
         try {
             if (!ignoreXmlConfiguration) {
                 loader = Reflection.loaderFromThreadOrClass(ValidationParser.class);
                 validationParser = new ValidationParser(loader);
                 final BootstrapConfiguration xmlBootstrap =
                     validationParser.processValidationConfig(getProperties().get(Properties.VALIDATION_XML_PATH), this);
                 if (xmlBootstrap != null) {
                     return xmlBootstrap;
                 }
             }
             validationParser =
                 new ValidationParser(loader = Reflection.loaderFromThreadOrClass(ApacheValidatorFactory.class));

             return BootstrapConfigurationImpl.DEFAULT;
         } finally {
             participantFactory = new ParticipantFactory(loader);
         }
     }

     private void applyBootstrapConfiguration() {
         final BootstrapConfiguration bootstrapConfig = bootstrapConfiguration.get();

         if (bootstrapConfig.getDefaultProviderClassName() != null) {
             this.providerClass = loadClass(bootstrapConfig.getDefaultProviderClassName());
         }
         bootstrapConfig.getProperties().forEach(this::addProperty);
         bootstrapConfig.getConstraintMappingResourcePaths().stream().map(validationParser::open)
             .forEach(this::addMapping);

         if (!beforeCdi) {
             performBootstrapOverrides();
         }
     }

     private void performBootstrapOverrides() {
         final BootstrapConfiguration bootstrapConfig = bootstrapConfiguration.get();
         override(messageInterpolator, bootstrapConfig::getMessageInterpolatorClassName);
         override(traversableResolver, bootstrapConfig::getTraversableResolverClassName);
         override(constraintValidatorFactory, bootstrapConfig::getConstraintValidatorFactoryClassName);
         override(parameterNameProvider, bootstrapConfig::getParameterNameProviderClassName);
         override(clockProvider, bootstrapConfig::getClockProviderClassName);

         bootstrapConfig.getValueExtractorClassNames().stream().<ValueExtractor<?>> map(participantFactory::create)
             .forEach(bootstrapValueExtractors::add);
     }

     @SuppressWarnings("unchecked")
     private <T> Class<T> loadClass(final String className) {
         try {
             return (Class<T>) Class.forName(className, true, loader);
         } catch (final ClassNotFoundException ex) {
             throw new ValidationException(ex);
         }
     }

     private ValidationProvider<?> findProvider() {
         if (providerClass == null) {
             return providerResolver.getValidationProviders().get(0);
         }
         final Optional<ValidationProvider<?>> knownProvider =
             providerResolver.getValidationProviders().stream().filter(providerClass::isInstance).findFirst();
         if (knownProvider.isPresent()) {
             return knownProvider.get();
         }
         try {
             return providerClass.getConstructor().newInstance();
         } catch (Exception e) {
             throw Exceptions.create(ValidationException::new, "Unable to find/create %s of type %s",
                 ValidationProvider.class.getSimpleName(), providerClass);
         }
     }

     private <T> void override(LazyParticipant<T> participant, Supplier<String> getClassName) {
         Optional.ofNullable(getClassName.get()).<T> map(participantFactory::create).ifPresent(participant::override);
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.bval.jsr;

	import java.io.Closeable;
	import java.io.InputStream;
	import java.time.Clock;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.LinkedHashSet;
	import java.util.Map;
	import java.util.Optional;
	import java.util.Set;
	import java.util.function.Supplier;

	import javax.validation.BootstrapConfiguration;
	import javax.validation.ClockProvider;
	import javax.validation.ConstraintValidatorFactory;
	import javax.validation.MessageInterpolator;
	import javax.validation.ParameterNameProvider;
	import javax.validation.TraversableResolver;
	import javax.validation.ValidationException;
	import javax.validation.ValidationProviderResolver;
	import javax.validation.ValidatorFactory;
	import javax.validation.spi.BootstrapState;
	import javax.validation.spi.ConfigurationState;
	import javax.validation.spi.ValidationProvider;
	import javax.validation.valueextraction.ValueExtractor;

	import org.apache.bval.jsr.parameter.DefaultParameterNameProvider;
	import org.apache.bval.jsr.resolver.DefaultTraversableResolver;
	import org.apache.bval.jsr.util.IOs;
	import org.apache.bval.jsr.valueextraction.ValueExtractors;
	import org.apache.bval.jsr.xml.ValidationParser;
	import org.apache.bval.util.CloseableAble;
	import org.apache.bval.util.Exceptions;
	import org.apache.bval.util.Lazy;
	import org.apache.bval.util.reflection.Reflection;
	import org.apache.commons.weaver.privilizer.Privileged;

	/**
	* Description: used to configure apache-validation for jsr.
	* Implementation of Configuration that also implements ConfigurationState,
	* hence this can be passed to buildValidatorFactory(ConfigurationState).
	* <br/>
	*/
	public class ConfigurationImpl implements ApacheValidatorConfiguration, ConfigurationState, CloseableAble {

	private class LazyParticipant<T> extends Lazy<T> {
	private boolean locked;

	private LazyParticipant(Supplier<T> init) {
	super(init);
	}

	ConfigurationImpl override(T value) {
	if (value != null) {
	synchronized (this) {
	if (!locked) {
	try {
	reset(() -> value);
	} finally {
	ConfigurationImpl.this.prepared = false;
	}
	}
	}
	}
	return ConfigurationImpl.this;
	}

	synchronized ConfigurationImpl externalOverride(T value) {
	locked = false;
	try {
	return override(value);
	} finally {
	locked = true;
	}
	}
	}

	/**
	* Configured {@link ValidationProvider}
	*/
	//couldn't this be parameterized <ApacheValidatorConfiguration> or <? super ApacheValidatorConfiguration>?
	private final ValidationProvider<ApacheValidatorConfiguration> provider;

	/**
	* Configured {@link ValidationProviderResolver}
	*/
	private final ValidationProviderResolver providerResolver;

	/**
	* Configured {@link ValidationProvider} class
	*/
	private Class<? extends ValidationProvider<?>> providerClass;

	private final MessageInterpolator defaultMessageInterpolator = new DefaultMessageInterpolator();

	private final LazyParticipant<MessageInterpolator> messageInterpolator =
	new LazyParticipant<>(this::getDefaultMessageInterpolator);

	private final ConstraintValidatorFactory defaultConstraintValidatorFactory =
	new DefaultConstraintValidatorFactory();

	private final LazyParticipant<ConstraintValidatorFactory> constraintValidatorFactory =
	new LazyParticipant<>(this::getDefaultConstraintValidatorFactory);

	private final TraversableResolver defaultTraversableResolver = new DefaultTraversableResolver();

	private final LazyParticipant<TraversableResolver> traversableResolver =
	new LazyParticipant<>(this::getDefaultTraversableResolver);

	private final ParameterNameProvider defaultParameterNameProvider = new DefaultParameterNameProvider();

	private final LazyParticipant<ParameterNameProvider> parameterNameProvider =
	new LazyParticipant<>(this::getDefaultParameterNameProvider);

	private final ClockProvider defaultClockProvider = Clock::systemDefaultZone;

	private final LazyParticipant<ClockProvider> clockProvider = new LazyParticipant<>(this::getDefaultClockProvider);

	private final ValueExtractors bootstrapValueExtractors = ValueExtractors.EMPTY.createChild();
	private final ValueExtractors valueExtractors = bootstrapValueExtractors.createChild();

	private final Lazy<BootstrapConfiguration> bootstrapConfiguration = new Lazy<>(this::createBootstrapConfiguration);

	private final Set<InputStream> mappingStreams = new HashSet<>();
	private final Map<String, String> properties = new HashMap<>();

	private boolean beforeCdi = false;
	private ClassLoader loader;

	// BEGIN DEFAULTS
	/**
	* false = dirty flag (to prevent from multiple parsing validation.xml)
	*/
	private boolean prepared = false;
	// END DEFAULTS

	private boolean ignoreXmlConfiguration = false;

	private ParticipantFactory participantFactory;
	private ValidationParser validationParser;

	/**
	* Create a new ConfigurationImpl instance.
	* @param aState bootstrap state
	* @param aProvider provider
	*/
	public ConfigurationImpl(BootstrapState aState, ValidationProvider<ApacheValidatorConfiguration> aProvider) {
	Exceptions.raiseIf(aProvider == null && aState == null, ValidationException::new,
	"one of provider or state is required");

	if (aProvider == null) {
	this.provider = null;
	if (aState.getValidationProviderResolver() == null) {
	providerResolver = aState.getDefaultValidationProviderResolver();
	} else {
	providerResolver = aState.getValidationProviderResolver();
	}
	} else {
	this.provider = aProvider;
	this.providerResolver = null;
	}
	}

	/**
	* {@inheritDoc}
	* Ignore data from the <i>META-INF/validation.xml</i> file if this
	* method is called.
	*
	* @return this
	*/
	@Override
	public ApacheValidatorConfiguration ignoreXmlConfiguration() {
	ignoreXmlConfiguration = true;
	return this;
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public ConfigurationImpl messageInterpolator(MessageInterpolator resolver) {
	return messageInterpolator.externalOverride(resolver);
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public ApacheValidatorConfiguration traversableResolver(TraversableResolver resolver) {
	return traversableResolver.externalOverride(resolver);
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public ConfigurationImpl constraintValidatorFactory(ConstraintValidatorFactory constraintValidatorFactory) {
	return this.constraintValidatorFactory.externalOverride(constraintValidatorFactory);
	}

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

	@Override
	public ApacheValidatorConfiguration clockProvider(ClockProvider clockProvider) {
	return this.clockProvider.externalOverride(clockProvider);
	}

	/**
	* {@inheritDoc}
	* Add a stream describing constraint mapping in the Bean Validation
	* XML format.
	*
	* @return this
	*/
	@Override
	public ApacheValidatorConfiguration addMapping(InputStream stream) {
	if (stream != null) {
	mappingStreams.add(IOs.convertToMarkableInputStream(stream));
	}
	return this;
	}

	/**
	* {@inheritDoc}
	* Add a provider specific property. This property is equivalent to
	* XML configuration properties.
	* If we do not know how to handle the property, we silently ignore it.
	*
	* @return this
	*/
	@Override
	public ApacheValidatorConfiguration addProperty(String name, String value) {
	properties.put(name, value);
	return this;
	}

	@Override
	public MessageInterpolator getDefaultMessageInterpolator() {
	return defaultMessageInterpolator;
	}

	@Override
	public TraversableResolver getDefaultTraversableResolver() {
	return defaultTraversableResolver;
	}

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

	@Override
	public ParameterNameProvider getDefaultParameterNameProvider() {
	return defaultParameterNameProvider;
	}

	@Override
	public ClockProvider getDefaultClockProvider() {
	return defaultClockProvider;
	}

	/**
	* {@inheritDoc}
	* Return a map of non type-safe custom properties.
	*
	* @return null
	*/
	@Override
	public Map<String, String> getProperties() {
	return properties;
	}

	/**
	* {@inheritDoc}
	* Returns true if Configuration.ignoreXMLConfiguration() has been called.
	* In this case, we ignore META-INF/validation.xml
	*
	* @return true
	*/
	@Override
	public boolean isIgnoreXmlConfiguration() {
	return ignoreXmlConfiguration;
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public Set<InputStream> getMappingStreams() {
	return mappingStreams;
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public MessageInterpolator getMessageInterpolator() {
	return messageInterpolator.get();
	}

	@Override
	public BootstrapConfiguration getBootstrapConfiguration() {
	return bootstrapConfiguration.get();
	}

	/**
	* {@inheritDoc}
	* main factory method to build a ValidatorFactory
	*
	* @throws ValidationException if the ValidatorFactory cannot be built
	*/
	@Override
	public ValidatorFactory buildValidatorFactory() {
	return doBuildValidatorFactory();
	}

	/**
	* {@inheritDoc}
	* @return the constraint validator factory of this configuration.
	*/
	@Override
	public ConstraintValidatorFactory getConstraintValidatorFactory() {
	return constraintValidatorFactory.get();
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public TraversableResolver getTraversableResolver() {
	return traversableResolver.get();
	}

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

	@Override
	public ClockProvider getClockProvider() {
	return clockProvider.get();
	}

	@Override
	public ApacheValidatorConfiguration addValueExtractor(ValueExtractor<?> extractor) {
	valueExtractors.add(extractor);
	return this;
	}

	@Override
	public Set<ValueExtractor<?>> getValueExtractors() {
	return Collections.unmodifiableSet(new LinkedHashSet<>(valueExtractors.getValueExtractors().values()));
	}

	public void deferBootstrapOverrides() {
	beforeCdi = true;
	}

	public void releaseDeferredBootstrapOverrides() {
	if (beforeCdi) {
	beforeCdi = false;
	performBootstrapOverrides();
	}
	}

	@Override
	public Closeable getCloseable() {
	if (participantFactory == null) {
	return () -> {
	};
	}
	return participantFactory;
	}

	@Privileged
	private ValidatorFactory doBuildValidatorFactory() {
	prepare();
	return Optional.<ValidationProvider<?>> ofNullable(provider).orElseGet(this::findProvider)
	.buildValidatorFactory(this);
	}

	private void prepare() {
	if (!prepared) {
	applyBootstrapConfiguration();
	prepared = true;
	}
	}

	private BootstrapConfiguration createBootstrapConfiguration() {
	try {
	if (!ignoreXmlConfiguration) {
	loader = Reflection.loaderFromThreadOrClass(ValidationParser.class);
	validationParser = new ValidationParser(loader);
	final BootstrapConfiguration xmlBootstrap =
	validationParser.processValidationConfig(getProperties().get(Properties.VALIDATION_XML_PATH), this);
	if (xmlBootstrap != null) {
	return xmlBootstrap;
	}
	}
	validationParser =
	new ValidationParser(loader = Reflection.loaderFromThreadOrClass(ApacheValidatorFactory.class));

	return BootstrapConfigurationImpl.DEFAULT;
	} finally {
	participantFactory = new ParticipantFactory(loader);
	}
	}

	private void applyBootstrapConfiguration() {
	final BootstrapConfiguration bootstrapConfig = bootstrapConfiguration.get();

	if (bootstrapConfig.getDefaultProviderClassName() != null) {
	this.providerClass = loadClass(bootstrapConfig.getDefaultProviderClassName());
	}
	bootstrapConfig.getProperties().forEach(this::addProperty);
	bootstrapConfig.getConstraintMappingResourcePaths().stream().map(validationParser::open)
	.forEach(this::addMapping);

	if (!beforeCdi) {
	performBootstrapOverrides();
	}
	}

	private void performBootstrapOverrides() {
	final BootstrapConfiguration bootstrapConfig = bootstrapConfiguration.get();
	override(messageInterpolator, bootstrapConfig::getMessageInterpolatorClassName);
	override(traversableResolver, bootstrapConfig::getTraversableResolverClassName);
	override(constraintValidatorFactory, bootstrapConfig::getConstraintValidatorFactoryClassName);
	override(parameterNameProvider, bootstrapConfig::getParameterNameProviderClassName);
	override(clockProvider, bootstrapConfig::getClockProviderClassName);

	bootstrapConfig.getValueExtractorClassNames().stream().<ValueExtractor<?>> map(participantFactory::create)
	.forEach(bootstrapValueExtractors::add);
	}

	@SuppressWarnings("unchecked")
	private <T> Class<T> loadClass(final String className) {
	try {
	return (Class<T>) Class.forName(className, true, loader);
	} catch (final ClassNotFoundException ex) {
	throw new ValidationException(ex);
	}
	}

	private ValidationProvider<?> findProvider() {
	if (providerClass == null) {
	return providerResolver.getValidationProviders().get(0);
	}
	final Optional<ValidationProvider<?>> knownProvider =
	providerResolver.getValidationProviders().stream().filter(providerClass::isInstance).findFirst();
	if (knownProvider.isPresent()) {
	return knownProvider.get();
	}
	try {
	return providerClass.getConstructor().newInstance();
	} catch (Exception e) {
	throw Exceptions.create(ValidationException::new, "Unable to find/create %s of type %s",
	ValidationProvider.class.getSimpleName(), providerClass);
	}
	}

	private <T> void override(LazyParticipant<T> participant, Supplier<String> getClassName) {
	Optional.ofNullable(getClassName.get()).<T> map(participantFactory::create).ifPresent(participant::override);
	}
	}