javax.validation.Configuration Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of validation-api Show documentation
Bean Validation API
There is a newer version: 2.0.1.Final
// $Id: Configuration.java 17620 2009-10-04 19:19:28Z hardy.ferentschik $
/*
* JBoss, Home of Professional Open Source
* Copyright 2009, Red Hat, Inc. and/or its affiliates, and individual contributors
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* Licensed 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 javax.validation;

import java.io.InputStream;

/**
 * Receives configuration information, selects the appropriate
 * Bean Validation provider and builds the appropriate ValidatorFactory.
 * 
 * Usage:
 * 
 * {@code
 * Configuration configuration = //provided by one of the Validation bootstrap methods
 *     ValidatorFactory = configuration
 *         .messageInterpolator( new CustomMessageInterpolator() )
 *         .buildValidatorFactory();}
 * 
 * 
 * By default, the configuration information is retrieved from
 * META-INF/validation.xml.
 * It is possible to override the configuration retrieved from the XML file
 * by using one or more of the Configuration methods.
 * 

 * The {@link ValidationProviderResolver} is specified at configuration time
 * (see {@link javax.validation.spi.ValidationProvider}).
 * If none is explicitly requested, the default ValidationProviderResolver is used.
 * 

 * The provider is selected in the following way:
 * 

 * if a specific provider is requested programmatically using
 * Validation.byProvider(Class), find the first provider implementing
 * the provider class requested and use it
 * if a specific provider is requested in META-INF/validation.xml,
 * find the first provider implementing the provider class requested and use it
 * otherwise, use the first provider returned by the ValidationProviderResolver

 * 

 * 
 * Implementations are not meant to be thread-safe.
 *
 * @author Emmanuel Bernard
 */
public interface Configuration> {

	/**
	 * Ignore data from the META-INF/validation.xml file if this
	 * method is called.
	 * This method is typically useful for containers that parse
	 * META-INF/validation.xml themselves and pass the information
	 * via the Configuration methods.
	 *
	 * @return this following the chaining method pattern.
	 */
	T ignoreXmlConfiguration();

	/**
	 * Defines the message interpolator used. Has priority over the configuration
	 * based message interpolator.
	 * If null is passed, the default message interpolator is used
	 * (defined in XML or the specification default).
	 *
	 * @param interpolator message interpolator implementation.
	 *
	 * @return this following the chaining method pattern.
	 */
	T messageInterpolator(MessageInterpolator interpolator);

	/**
	 * Defines the traversable resolver used. Has priority over the configuration
	 * based traversable resolver.
	 * If null is passed, the default traversable resolver is used
	 * (defined in XML or the specification default).
	 *
	 * @param resolver traversable resolver implementation.
	 *
	 * @return this following the chaining method pattern.
	 */
	T traversableResolver(TraversableResolver resolver);

	/**
	 * Defines the constraint validator factory. Has priority over the configuration
	 * based constraint factory.
	 * If null is passed, the default constraint validator factory is used
	 * (defined in XML or the specification default).
	 *
	 * @param constraintValidatorFactory constraint factory inmplementation.
	 *
	 * @return this following the chaining method pattern.
	 */
	T constraintValidatorFactory(ConstraintValidatorFactory constraintValidatorFactory);

	/**
	 * Add a stream describing constraint mapping in the Bean Validation
	 * XML format.
	 * 

	 * The stream should be closed by the client API after the
	 * ValidatorFactory has been built. The Bean Validation provider
	 * must not close the stream.
	 *
	 * @param stream XML mapping stream.
	 *
	 * @return this following the chaining method pattern.
	 * @throws IllegalArgumentException if stream is null
	 */
	T addMapping(InputStream stream);

	/**
	 * Add a provider specific property. This property is equivalent to
	 * XML configuration properties.
	 * If the underlying provider does not know how to handle the property,
	 * it must silently ignore it.
	 * 

	 * Note: Using this non type-safe method is generally not recommended.
	 * 

	 * It is more appropriate to use, if available, the type-safe equivalent provided
	 * by a specific provider via its Configuration subclass.
	 * ValidatorFactory factory = Validation.byProvider(ACMEPrivoder.class)
	 * .configure()
	 * .providerSpecificProperty(ACMEState.FAST)
	 * .buildValidatorFactory();
	 * 
	 * This method is typically used by containers parsing META-INF/validation.xml
	 * themselves and injecting the state to the Configuration object.
	 * 

	 * If a property with a given name is defined both via this method and in the
	 * XML configuration, the value set programmatically has priority.
	 *
	 * If null is passed as a value, the value defined in XML is used. If no value
	 * is defined in XML, the property is considered unset.
	 *
	 * @param name property name.
	 * @param value property value.
	 * @return this following the chaining method pattern.
	 *
	 * @throws IllegalArgumentException if name is null
	 */
	T addProperty(String name, String value);

	/**
	 * Return an implementation of the MessageInterpolator interface
	 * following the default MessageInterpolator defined in the
	 * specification:
	 * 

	 * use the ValidationMessages resource bundle to load keys
	 * use Locale.getDefault()
	 * 

	 *
	 * @return default MessageInterpolator implementation compliant with the specification
	 */
	MessageInterpolator getDefaultMessageInterpolator();

	/**
	 * Return an implementation of the TraversableResolver interface
	 * following the default TraversableResolver defined in the
	 * specification:
	 * 
	 * if Java Persistence is available in the runtime environment, 
	 * a property is considered reachable if Java Persistence considers
	 * the property as loaded
	 * if Java Persistence is not available in the runtime environment,
	 * all properties are considered reachable
	 * all properties are considered cascadable.
	 * 
	 *
	 * @return default TraversableResolver implementation compliant with the specification
	 */
	TraversableResolver getDefaultTraversableResolver();

	/**
	 * Return an implementation of the ConstraintValidatorFactory interface
	 * following the default ConstraintValidatorFactory defined in the
	 * specification:
	 * 
	 * uses the public no-arg constructor of the ConstraintValidator
	 * 
	 *
	 * @return default ConstraintValidatorFactory implementation compliant with the specification
	 */
	ConstraintValidatorFactory getDefaultConstraintValidatorFactory();

	/**
	 * Build a ValidatorFactory implementation.
	 *
	 * @return ValidatorFactory
	 * @throws ValidationException if the ValidatorFactory cannot be built
	 */
	ValidatorFactory buildValidatorFactory();
}