javax.validation.super.javax.validation.Configuration Maven / Gradle / Ivy
// $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.
*/
// Changed by Google
package javax.validation;
/**
* 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(String 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();
}