Bootstrap and Configuration

/**
 * Bootstrap entry point for Jakarta Validation
 */
class Validation {
    /**
     * Build a ValidatorFactory using the default validation provider
     * @return ValidatorFactory instance
     */
    static ValidatorFactory buildDefaultValidatorFactory();
    
    /**
     * Get a generic bootstrap instance for provider-agnostic configuration
     * @return GenericBootstrap instance
     */
    static GenericBootstrap byDefaultProvider();
    
    /**
     * Get a provider-specific bootstrap for a particular validation provider
     * @param providerType the validation provider class
     * @return provider-specific bootstrap instance
     */
    static <T extends Configuration<T>, U extends ValidationProvider<T>> 
        ProviderSpecificBootstrap<T> byProvider(Class<U> providerType);
}

import jakarta.validation.Validation;
import jakarta.validation.ValidatorFactory;

// Default setup - simplest approach
ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();

// Provider-agnostic bootstrap
GenericBootstrap bootstrap = Validation.byDefaultProvider();
Configuration<?> config = bootstrap.configure();
ValidatorFactory customFactory = config.buildValidatorFactory();

/**
 * Factory for Validator instances and access to validation configuration
 * Implementations must be thread-safe
 */
interface ValidatorFactory extends AutoCloseable {
    /**
     * Get a Validator instance for validation operations
     * @return thread-safe Validator instance
     */
    Validator getValidator();
    
    /**
     * Get a ValidatorContext for creating customized validators
     * @return ValidatorContext for customization
     */
    ValidatorContext usingContext();
    
    /**
     * Get the MessageInterpolator used by this factory
     * @return MessageInterpolator instance
     */
    MessageInterpolator getMessageInterpolator();
    
    /**
     * Get the TraversableResolver used by this factory
     * @return TraversableResolver instance
     */
    TraversableResolver getTraversableResolver();
    
    /**
     * Get the ConstraintValidatorFactory used by this factory
     * @return ConstraintValidatorFactory instance
     */
    ConstraintValidatorFactory getConstraintValidatorFactory();
    
    /**
     * Get the ParameterNameProvider used by this factory
     * @return ParameterNameProvider instance
     */
    ParameterNameProvider getParameterNameProvider();
    
    /**
     * Get the ClockProvider used by this factory
     * @return ClockProvider instance
     */
    ClockProvider getClockProvider();
    
    /**
     * Unwrap the ValidatorFactory to a specific type
     * @param type target type to unwrap to
     * @return unwrapped instance
     * @throws ValidationException if unwrapping is not supported
     */
    <T> T unwrap(Class<T> type);
    
    /**
     * Close the ValidatorFactory and release resources
     */
    void close();
}

/**
 * Configuration interface for setting up validation before building ValidatorFactory
 * @param <T> type of the configuration implementation
 */
interface Configuration<T extends Configuration<T>> {
    /**
     * Ignore META-INF/validation.xml configuration
     * @return this configuration instance
     */
    T ignoreXmlConfiguration();
    
    /**
     * Set a custom MessageInterpolator for constraint message interpolation
     * @param interpolator MessageInterpolator instance
     * @return this configuration instance
     */
    T messageInterpolator(MessageInterpolator interpolator);
    
    /**
     * Set a custom TraversableResolver for property traversal decisions
     * @param resolver TraversableResolver instance
     * @return this configuration instance
     */
    T traversableResolver(TraversableResolver resolver);
    
    /**
     * Set a custom ConstraintValidatorFactory for validator instantiation
     * @param constraintValidatorFactory ConstraintValidatorFactory instance
     * @return this configuration instance
     */
    T constraintValidatorFactory(ConstraintValidatorFactory constraintValidatorFactory);
    
    /**
     * Set a custom ParameterNameProvider for method parameter names
     * @param parameterNameProvider ParameterNameProvider instance
     * @return this configuration instance
     */
    T parameterNameProvider(ParameterNameProvider parameterNameProvider);
    
    /**
     * Set a custom ClockProvider for time-based validations
     * @param clockProvider ClockProvider instance
     * @return this configuration instance
     */
    T clockProvider(ClockProvider clockProvider);
    
    /**
     * Add a ValueExtractor for container element validation
     * @param extractor ValueExtractor instance
     * @return this configuration instance
     */
    T addValueExtractor(ValueExtractor<?> extractor);
    
    /**
     * Add constraint mapping stream for programmatic constraint definition
     * @param stream InputStream containing constraint mappings
     * @return this configuration instance
     */
    T addMapping(InputStream stream);
    
    /**
     * Add a configuration property
     * @param name property name
     * @param value property value
     * @return this configuration instance
     */
    T addProperty(String name, String value);
    
    /**
     * Build the configured ValidatorFactory
     * @return configured ValidatorFactory instance
     */
    ValidatorFactory buildValidatorFactory();
}

/**
 * Generic bootstrap for provider-agnostic configuration
 */
interface GenericBootstrap {
    /**
     * Set a custom ValidationProviderResolver
     * @param resolver ValidationProviderResolver instance
     * @return this bootstrap instance
     */
    GenericBootstrap providerResolver(ValidationProviderResolver resolver);
    
    /**
     * Create a generic configuration instance
     * @return Configuration instance
     */
    Configuration<?> configure();
}

/**
 * Provider-specific bootstrap for targeted validation provider configuration
 * @param <T> type of the provider-specific configuration
 */
interface ProviderSpecificBootstrap<T extends Configuration<T>> {
    /**
     * Set a custom ValidationProviderResolver
     * @param resolver ValidationProviderResolver instance
     * @return this bootstrap instance
     */
    ProviderSpecificBootstrap<T> providerResolver(ValidationProviderResolver resolver);
    
    /**
     * Create a provider-specific configuration instance
     * @return provider-specific Configuration instance
     */
    T configure();
}

/**
 * Context for creating customized Validator instances
 */
interface ValidatorContext {
    /**
     * Set a custom MessageInterpolator for this validator
     * @param messageInterpolator MessageInterpolator instance
     * @return this context instance
     */
    ValidatorContext messageInterpolator(MessageInterpolator messageInterpolator);
    
    /**
     * Set a custom TraversableResolver for this validator
     * @param traversableResolver TraversableResolver instance
     * @return this context instance
     */
    ValidatorContext traversableResolver(TraversableResolver traversableResolver);
    
    /**
     * Set a custom ConstraintValidatorFactory for this validator
     * @param factory ConstraintValidatorFactory instance
     * @return this context instance
     */
    ValidatorContext constraintValidatorFactory(ConstraintValidatorFactory factory);
    
    /**
     * Set a custom ParameterNameProvider for this validator
     * @param parameterNameProvider ParameterNameProvider instance
     * @return this context instance
     */
    ValidatorContext parameterNameProvider(ParameterNameProvider parameterNameProvider);
    
    /**
     * Set a custom ClockProvider for this validator
     * @param clockProvider ClockProvider instance
     * @return this context instance
     */
    ValidatorContext clockProvider(ClockProvider clockProvider);
    
    /**
     * Get the configured Validator instance
     * @return customized Validator instance
     */
    Validator getValidator();
}

/**
 * Configuration information from META-INF/validation.xml
 */
interface BootstrapConfiguration {
    /**
     * Get the default validation provider class name
     * @return provider class name or null if not specified
     */
    String getDefaultProviderClassName();
    
    /**
     * Get constraint validator factory class name
     * @return factory class name or null if not specified
     */
    String getConstraintValidatorFactoryClassName();
    
    /**
     * Get message interpolator class name
     * @return interpolator class name or null if not specified
     */
    String getMessageInterpolatorClassName();
    
    /**
     * Get traversable resolver class name
     * @return resolver class name or null if not specified
     */
    String getTraversableResolverClassName();
    
    /**
     * Get parameter name provider class name
     * @return provider class name or null if not specified
     */
    String getParameterNameProviderClassName();
    
    /**
     * Get clock provider class name
     * @return provider class name or null if not specified
     */
    String getClockProviderClassName();
    
    /**
     * Get value extractor class names
     * @return set of extractor class names
     */
    Set<String> getValueExtractorClassNames();
    
    /**
     * Get constraint mapping resource paths
     * @return set of resource paths
     */
    Set<String> getConstraintMappingResourcePaths();
    
    /**
     * Get configuration properties
     * @return map of property names to values
     */
    Map<String, String> getProperties();
    
    /**
     * Get executable validation configuration
     * @return ExecutableValidation configuration
     */
    ExecutableValidation getExecutableValidation();
    
    /**
     * Check if executable validation is enabled by default
     * @return true if enabled by default
     */
    boolean isExecutableValidationEnabled();
}

import jakarta.validation.*;

// Custom configuration example
Configuration<?> config = Validation.byDefaultProvider()
    .configure()
    .messageInterpolator(new CustomMessageInterpolator())
    .constraintValidatorFactory(new CustomValidatorFactory())
    .addProperty("hibernate.validator.fail_fast", "true");

ValidatorFactory factory = config.buildValidatorFactory();
Validator validator = factory.getValidator();

// Validator context customization
Validator customValidator = factory.usingContext()
    .messageInterpolator(new SpecialMessageInterpolator())
    .getValidator();