@SuppressWarnings("unchecked") private ConstraintValidator<A, ?> getInitializedConstraintValidator(ValidationContext<?> validationContext) { ConstraintValidator<A, ?> validator = validationContext.getConstraintValidatorManager().getInitializedValidator( validatedValueType, descriptor, validationContext.getConstraintValidatorFactory(), validationContext.getConstraintValidatorInitializationContext() ); if ( validator != null ) { return validator; } else { return (ConstraintValidator<A, ?>) DUMMY_CONSTRAINT_VALIDATOR; } }
private <T, V> ConstraintValidator<A, V> getConstraintValidatorNoUnwrapping(ValidationContext<T> validationContext, ValueContext<?, V> valueContext) { // make sure no unwrapper is set valueContext.setValidatedValueHandler( null ); Type validatedValueType = valueContext.getDeclaredTypeOfValidatedElement(); ConstraintValidator<A, V> validator = validationContext.getConstraintValidatorManager() .getInitializedValidator( validatedValueType, descriptor, validationContext.getConstraintValidatorFactory() ); if ( validator == null ) { throwExceptionForNullValidator( validatedValueType, valueContext.getPropertyPath().asString() ); } return validator; }
private <T, V> ConstraintValidator<A, V> getInitializedValidatorInstanceForWrappedInstance(ValidationContext<T> validationContext, ValueContext<?, V> valueContext, Type validatedValueType, ValidatedValueUnwrapper<V> validatedValueUnwrapper) { // make sure that unwrapper is set if ( validatedValueUnwrapper == null ) { throw log.getNoUnwrapperFoundForTypeException( valueContext.getDeclaredTypeOfValidatedElement() ); } valueContext.setValidatedValueHandler( validatedValueUnwrapper ); validatedValueType = validatedValueUnwrapper.getValidatedValueType( validatedValueType ); ConstraintValidator<A, V> validator = validationContext.getConstraintValidatorManager() .getInitializedValidator( validatedValueType, descriptor, validationContext.getConstraintValidatorFactory() ); if ( validator == null ) { throwExceptionForNullValidator( validatedValueType, valueContext.getPropertyPath().asString() ); } return validator; }
validatedValueUnwrapper.getValidatedValueType( validatedValueType ), descriptor, validationContext.getConstraintValidatorFactory() ); valueContext.getDeclaredTypeOfValidatedElement(), descriptor, validationContext.getConstraintValidatorFactory() );
protected final <T> ConstraintValidator<A, ?> getInitializedConstraintValidator(ValidationContext<T> validationContext, ValueContext<?, ?> valueContext) { ConstraintValidator<A, ?> validator; if ( validationContext.getConstraintValidatorFactory() == validationContext.getConstraintValidatorManager().getDefaultConstraintValidatorFactory() && validationContext.getConstraintValidatorInitializationContext() == validationContext.getConstraintValidatorManager() .getDefaultConstraintValidatorInitializationContext() ) { validator = constraintValidatorForDefaultConstraintValidatorFactoryAndInitializationContext; if ( validator == null ) { synchronized ( this ) { validator = constraintValidatorForDefaultConstraintValidatorFactoryAndInitializationContext; if ( validator == null ) { validator = getInitializedConstraintValidator( validationContext ); constraintValidatorForDefaultConstraintValidatorFactoryAndInitializationContext = validator; } } } } else { // For now, we don't cache the result in the ConstraintTree if we don't use the default constraint validator // factory. Creating a lot of CHM for that cache might not be a good idea and we prefer being conservative // for now. Note that we have the ConstraintValidatorManager cache that mitigates the situation. // If you come up with a use case where it makes sense, please reach out to us. validator = getInitializedConstraintValidator( validationContext ); } if ( validator == DUMMY_CONSTRAINT_VALIDATOR ) { throw getExceptionForNullValidator( validatedValueType, valueContext.getPropertyPath().asString() ); } return validator; }