Hibernate Validator

import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;
import org.hibernate.validator.HibernateValidator;
import org.hibernate.validator.HibernateValidatorConfiguration;
import org.hibernate.validator.HibernateValidatorFactory;

import jakarta.validation.ConstraintViolation;
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import org.hibernate.validator.HibernateValidator;
import org.hibernate.validator.constraints.Length;
import java.util.Set;

// Define a bean with constraints
public class User {
    @NotNull
    @Size(min = 2, max = 50)
    private String name;

    @Length(min = 5, max = 100)  // Hibernate-specific constraint
    private String email;

    // Constructor, getters, setters...
}

// Bootstrap Hibernate Validator
ValidatorFactory factory = Validation
    .byProvider(HibernateValidator.class)
    .configure()
    .failFast(true)  // Stop on first violation
    .buildValidatorFactory();

Validator validator = factory.getValidator();

// Validate an object
User user = new User();
user.setName("J");
user.setEmail("bad");

Set<ConstraintViolation<User>> violations = validator.validate(user);

// Process violations
for (ConstraintViolation<User> violation : violations) {
    System.out.println(violation.getPropertyPath() + ": " + violation.getMessage());
}

factory.close();

/**
 * Default implementation of ValidationProvider for full-scope validation.
 */
class HibernateValidator implements ValidationProvider<HibernateValidatorConfiguration> {
    HibernateValidatorConfiguration createSpecializedConfiguration(BootstrapState state);
    Configuration<?> createGenericConfiguration(BootstrapState state);
    ValidatorFactory buildValidatorFactory(ConfigurationState configurationState);
}

/**
 * Configuration interface for standard Hibernate Validator usage.
 * Extends Jakarta Validation Configuration with Hibernate-specific options.
 */
interface HibernateValidatorConfiguration
    extends BaseHibernateValidatorConfiguration<HibernateValidatorConfiguration> {
}

/**
 * Factory for creating Validator instances with Hibernate-specific extensions.
 */
interface HibernateValidatorFactory extends ValidatorFactory {
    /**
     * Create a ValidatorContext with Hibernate-specific configuration options.
     */
    HibernateValidatorContext usingContext();

    ScriptEvaluatorFactory getScriptEvaluatorFactory();
    Duration getTemporalValidationTolerance();
    GetterPropertySelectionStrategy getGetterPropertySelectionStrategy();
    PropertyNodeNameProvider getPropertyNodeNameProvider();
}

/**
 * Context for creating Validator instances with per-validator configuration.
 */
interface HibernateValidatorContext extends ValidatorContext {
    HibernateValidatorContext failFast(boolean failFast);
    HibernateValidatorContext allowOverridingMethodAlterParameterConstraint(boolean allow);
    HibernateValidatorContext allowMultipleCascadedValidationOnReturnValues(boolean allow);
    HibernateValidatorContext allowParallelMethodsDefineParameterConstraints(boolean allow);
    HibernateValidatorContext enableTraversableResolverResultCache(boolean enabled);
    HibernateValidatorContext temporalValidationTolerance(Duration temporalValidationTolerance);
    HibernateValidatorContext constraintValidatorPayload(Object constraintValidatorPayload);
    HibernateValidatorContext showValidatedValuesInTraceLogs(boolean enabled);
    HibernateValidatorContext failFastOnPropertyViolation(boolean failFastOnPropertyViolation);
}

/**
 * String length constraint (Hibernate-specific alternative to @Size).
 */
@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
@Retention(RUNTIME)
@Constraint(validatedBy = {})
@interface Length {
    String message() default "{org.hibernate.validator.constraints.Length.message}";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    int min() default 0;
    int max() default Integer.MAX_VALUE;
}

/**
 * Credit card number validation using Luhn algorithm.
 */
@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
@Retention(RUNTIME)
@Constraint(validatedBy = {})
@interface CreditCardNumber {
    String message() default "{org.hibernate.validator.constraints.CreditCardNumber.message}";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    boolean ignoreNonDigitCharacters() default false;
}

/**
 * URL validation with protocol, host, and port constraints.
 */
@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
@Retention(RUNTIME)
@Constraint(validatedBy = {})
@interface URL {
    String message() default "{org.hibernate.validator.constraints.URL.message}";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    String protocol() default "";
    String host() default "";
    int port() default -1;
    String regexp() default ".*";
    Pattern.Flag[] flags() default {};
}

/**
 * Duration minimum constraint.
 */
@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
@Retention(RUNTIME)
@Constraint(validatedBy = {})
@interface DurationMin {
    String message() default "{org.hibernate.validator.constraints.time.DurationMin.message}";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    long days() default 0;
    long hours() default 0;
    long minutes() default 0;
    long seconds() default 0;
    long millis() default 0;
    long nanos() default 0;
    boolean inclusive() default true;
}

/**
 * Programmatic constraint mapping interface.
 */
interface ConstraintMapping {
    /**
     * Start defining constraints for a bean class.
     */
    <C> TypeConstraintMappingContext<C> type(Class<C> type);

    /**
     * Define custom constraint validators for a constraint annotation.
     */
    <A extends Annotation> ConstraintDefinitionContext<A> constraintDefinition(Class<A> annotationClass);
}

/**
 * Base class for constraint definitions in programmatic API.
 */
abstract class ConstraintDef<C extends ConstraintDef<C, A>, A extends Annotation>
    extends AnnotationDef<C, A> {
    C message(String message);
    C groups(Class<?>... groups);
    C payload(Class<? extends Payload>... payload);
}

/**
 * Generic constraint definition for constraints without specific type-safe class.
 */
class GenericConstraintDef<A extends Annotation> extends ConstraintDef<GenericConstraintDef<A>, A> {
    // Generic constraint definition
}

/**
 * Hibernate Validator extension to ConstraintValidator.
 */
interface HibernateConstraintValidator<A extends Annotation, T>
    extends ConstraintValidator<A, T> {
    /**
     * Initialize with enhanced Hibernate-specific context.
     */
    default void initialize(
        ConstraintDescriptor<A> constraintDescriptor,
        HibernateConstraintValidatorInitializationContext initializationContext
    ) {
        initialize(constraintDescriptor.getAnnotation());
    }
}

/**
 * Hibernate-specific constraint validator context with additional capabilities.
 */
interface HibernateConstraintValidatorContext extends ConstraintValidatorContext {
    /**
     * Add named message parameter for interpolation.
     */
    HibernateConstraintValidatorContext addMessageParameter(String name, Object value);

    /**
     * Add expression language variable for message interpolation.
     */
    HibernateConstraintValidatorContext addExpressionVariable(String name, Object value);

    /**
     * Set dynamic payload for constraint violation.
     */
    HibernateConstraintValidatorContext withDynamicPayload(Object payload);

    /**
     * Get constraint validator payload passed during configuration.
     */
    <C> C getConstraintValidatorPayload(Class<C> type);

    /**
     * Build constraint violation with Hibernate-specific features.
     */
    HibernateConstraintViolationBuilder buildConstraintViolationWithTemplate(String messageTemplate);
}

/**
 * Enhanced constraint violation containing dynamic payload.
 */
interface HibernateConstraintViolation<T> extends ConstraintViolation<T> {
    /**
     * Get dynamic payload set via HibernateConstraintValidatorContext.
     */
    <C> C getDynamicPayload(Class<C> type);
}

/**
 * Resource bundle-backed message interpolator with Expression Language support.
 */
class ResourceBundleMessageInterpolator extends AbstractMessageInterpolator {
    ResourceBundleMessageInterpolator();
    ResourceBundleMessageInterpolator(ResourceBundleLocator userResourceBundleLocator);
    ResourceBundleMessageInterpolator(
        ResourceBundleLocator userResourceBundleLocator,
        ResourceBundleLocator contributorResourceBundleLocator
    );
    ResourceBundleMessageInterpolator(
        ResourceBundleLocator userResourceBundleLocator,
        ResourceBundleLocator contributorResourceBundleLocator,
        boolean cachingEnabled
    );
}

/**
 * Message interpolator without EL support (parameter values only).
 */
class ParameterMessageInterpolator extends AbstractMessageInterpolator {
    ParameterMessageInterpolator();
}

/**
 * Expression Language feature level for security control.
 */
enum ExpressionLanguageFeatureLevel {
    DEFAULT,        // Context-dependent default
    NONE,          // No EL interpolation
    VARIABLES,     // Only injected variables, formatter, and ResourceBundles
    BEAN_PROPERTIES, // Variables plus bean properties (spec-compliant minimum)
    BEAN_METHODS;   // Bean properties plus method execution (security risk!)

    static ExpressionLanguageFeatureLevel of(String level);
    static ExpressionLanguageFeatureLevel interpretDefaultForConstraints(ExpressionLanguageFeatureLevel level);
    static ExpressionLanguageFeatureLevel interpretDefaultForCustomViolations(ExpressionLanguageFeatureLevel level);
}

/**
 * Property node with value access (Hibernate extension).
 */
interface PropertyNode extends jakarta.validation.Path.PropertyNode {
    /**
     * Get the value of the bean property represented by this node.
     */
    Object getValue();
}

/**
 * Container element node with value access (Hibernate extension).
 */
interface ContainerElementNode extends jakarta.validation.Path.ContainerElementNode {
    /**
     * Get the value of the container element represented by this node.
     */
    Object getValue();
}

/**
 * Default platform resource bundle locator.
 */
class PlatformResourceBundleLocator implements ResourceBundleLocator {
    PlatformResourceBundleLocator(String bundleName);
    PlatformResourceBundleLocator(String bundleName, ClassLoader classLoader);
    ResourceBundle getResourceBundle(Locale locale);
}

/**
 * Aggregates multiple resource bundle locators.
 */
class AggregateResourceBundleLocator implements ResourceBundleLocator {
    AggregateResourceBundleLocator(List<ResourceBundleLocator> resourceBundleLocators);
    ResourceBundle getResourceBundle(Locale locale);
}

/**
 * Caching resource bundle locator wrapper.
 */
class CachingResourceBundleLocator implements ResourceBundleLocator {
    CachingResourceBundleLocator(ResourceBundleLocator delegate);
    ResourceBundle getResourceBundle(Locale locale);
}

/**
 * Contributes constraint mappings to validator configuration.
 */
interface ConstraintMappingContributor {
    void createConstraintMappings(ConstraintMappingBuilder builder);

    interface ConstraintMappingBuilder {
        ConstraintMapping addConstraintMapping();
    }
}

/**
 * Provides default group sequence dynamically at validation time.
 */
interface DefaultGroupSequenceProvider<T> {
    List<Class<?>> getValidationGroups(T object);
}

/**
 * Resolves locale for message interpolation.
 */
interface LocaleResolver {
    Locale resolve(LocaleResolverContext context);
}

/**
 * Resolves property node names in validation paths.
 */
interface PropertyNodeNameProvider {
    String getName(Property property);
}

/**
 * Defines strategy for detecting JavaBean getters.
 */
interface GetterPropertySelectionStrategy {
    Optional<String> getProperty(ConstrainableExecutable executable);
    List<String> getGetterMethodNameCandidates(String propertyName);
}

/**
 * Factory for creating script evaluators.
 */
interface ScriptEvaluatorFactory {
    ScriptEvaluator getScriptEvaluatorByLanguageName(String languageName);
    void clear();
}

/**
 * Configuration property names for Hibernate Validator.
 * Defined in BaseHibernateValidatorConfiguration interface.
 */
class ConfigurationProperties {
    String FAIL_FAST = "hibernate.validator.fail_fast";
    String ALLOW_PARAMETER_CONSTRAINT_OVERRIDE = "hibernate.validator.allow_parameter_constraint_override";
    String ALLOW_MULTIPLE_CASCADED_VALIDATION_ON_RESULT = "hibernate.validator.allow_multiple_cascaded_validation_on_result";
    String ALLOW_PARALLEL_METHODS_DEFINE_PARAMETER_CONSTRAINTS = "hibernate.validator.allow_parallel_method_parameter_constraint";
    String CONSTRAINT_MAPPING_CONTRIBUTORS = "hibernate.validator.constraint_mapping_contributors";
    String ENABLE_TRAVERSABLE_RESOLVER_RESULT_CACHE = "hibernate.validator.enable_traversable_resolver_result_cache";
    String SCRIPT_EVALUATOR_FACTORY_CLASSNAME = "hibernate.validator.script_evaluator_factory";
    String TEMPORAL_VALIDATION_TOLERANCE = "hibernate.validator.temporal_validation_tolerance";
    String GETTER_PROPERTY_SELECTION_STRATEGY_CLASSNAME = "hibernate.validator.getter_property_selection_strategy";
    String PROPERTY_NODE_NAME_PROVIDER_CLASSNAME = "hibernate.validator.property_node_name_provider";
    String LOCALE_RESOLVER_CLASSNAME = "hibernate.validator.locale_resolver";
    String CONSTRAINT_EXPRESSION_LANGUAGE_FEATURE_LEVEL = "hibernate.validator.constraint_expression_language_feature_level";
    String CUSTOM_VIOLATION_EXPRESSION_LANGUAGE_FEATURE_LEVEL = "hibernate.validator.custom_violation_expression_language_feature_level";
    String SHOW_VALIDATED_VALUE_IN_TRACE_LOGS = "hibernate.validator.show_validated_value_in_trace_logs";
    String FAIL_FAST_ON_PROPERTY_VIOLATION = "hibernate.validator.fail_fast_on_property_violation";
}

/**
 * Marks API elements as incubating (subject to incompatible changes).
 */
@Documented
@Retention(RetentionPolicy.CLASS)
@interface Incubating {
}

package org.hibernate.validator;

import java.security.BasicPermission;

/**
 * Hibernate Validator specific implementation of BasicPermission.
 * Thread-safe and immutable.
 *
 * @deprecated This permission will be removed in future versions as
 *             Hibernate Validator no longer relies on SecurityManager.
 */
@Deprecated(forRemoval = true)
class HibernateValidatorPermission extends BasicPermission {
    /**
     * Permission to access private members for validation.
     */
    static final HibernateValidatorPermission ACCESS_PRIVATE_MEMBERS;

    /**
     * Create permission with name.
     *
     * @param name permission name
     */
    HibernateValidatorPermission(String name);

    /**
     * Create permission with name and actions.
     *
     * @param name permission name
     * @param actions permission actions
     */
    HibernateValidatorPermission(String name, String actions);
}