From 7f645c3984f6cbcb636d86b06da27b5a3bba6f9c Mon Sep 17 00:00:00 2001 From: Kevin Pollet Date: Mon, 20 Feb 2012 16:36:07 +0100 Subject: [PATCH] HV-481 Use JBoss logging logger as an exception factory --- .../validator/cfg/ConstraintMapping.java | 9 +- .../validator/cfg/GenericConstraintDef.java | 1 - .../cfg/context/ConfiguredConstraint.java | 9 +- .../ConstraintMappingContextImplBase.java | 26 +- ...ParameterConstraintMappingContextImpl.java | 6 +- .../DecimalMaxValidatorForCharSequence.java | 9 +- .../DecimalMaxValidatorForNumber.java | 9 +- .../DecimalMinValidatorForCharSequence.java | 9 +- .../DecimalMinValidatorForNumber.java | 9 +- .../DigitsValidatorForCharSequence.java | 9 +- .../DigitsValidatorForNumber.java | 9 +- .../constraintvalidators/LengthValidator.java | 11 +- .../ModCheckValidator.java | 26 +- .../PatternValidator.java | 7 +- .../ScriptAssertValidator.java | 31 +- .../SizeValidatorForArray.java | 12 +- .../SizeValidatorForArraysOfPrimitives.java | 12 +- .../SizeValidatorForCharSequence.java | 12 +- .../SizeValidatorForCollection.java | 12 +- .../SizeValidatorForMap.java | 12 +- .../internal/engine/ConfigurationImpl.java | 19 +- .../internal/engine/ConstraintTree.java | 17 +- .../ConstraintValidatorContextImpl.java | 10 +- .../validator/internal/engine/PathImpl.java | 12 +- .../internal/engine/ValidatorFactoryImpl.java | 12 +- .../internal/engine/ValidatorImpl.java | 56 ++- .../internal/engine/ValueContext.java | 18 +- .../internal/engine/groups/GroupChain.java | 8 +- .../engine/groups/GroupChainGenerator.java | 19 +- .../internal/metadata/BeanMetaDataCache.java | 11 +- .../metadata/aggregated/BeanMetaDataImpl.java | 13 +- .../metadata/aggregated/MethodMetaData.java | 9 +- .../metadata/core/ConstraintHelper.java | 63 +-- .../descriptor/BeanDescriptorImpl.java | 10 +- .../descriptor/ConstraintDescriptorImpl.java | 20 +- .../location/MethodConstraintLocation.java | 9 +- .../ProgrammaticMappingMetaDataProvider.java | 9 +- .../metadata/raw/ConstrainedMethod.java | 15 +- .../validator/internal/util/Contracts.java | 13 +- .../internal/util/LazyValidatorFactory.java | 10 +- .../internal/util/ReflectionHelper.java | 32 +- .../validator/internal/util/TypeHelper.java | 9 +- .../annotationfactory/AnnotationProxy.java | 10 +- .../validator/internal/util/logging/Log.java | 395 ++++++++++++++++++ .../ConstructorInstance.java | 15 +- .../GetAnnotationParameter.java | 20 +- .../privilegedactions/GetClassLoader.java | 11 +- .../util/privilegedactions/LoadClass.java | 12 +- .../util/privilegedactions/NewInstance.java | 13 +- .../scriptengine/ScriptEvaluatorFactory.java | 7 +- .../internal/xml/ValidationXmlParser.java | 36 +- .../internal/xml/XmlMappingParser.java | 51 +-- .../ValueFormatterMessageInterpolator.java | 13 +- .../AggregateResourceBundleLocator.java | 10 +- 54 files changed, 846 insertions(+), 381 deletions(-) diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/cfg/ConstraintMapping.java b/hibernate-validator/src/main/java/org/hibernate/validator/cfg/ConstraintMapping.java index 01926ee15f..2760c38d0e 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/cfg/ConstraintMapping.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/cfg/ConstraintMapping.java @@ -19,6 +19,9 @@ import org.hibernate.validator.cfg.context.TypeConstraintMappingContext; import org.hibernate.validator.internal.cfg.context.ConstraintMappingContext; import org.hibernate.validator.internal.cfg.context.TypeConstraintMappingContextImpl; +import org.hibernate.validator.internal.util.Contracts; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * Top level class for constraints configured via the programmatic API. @@ -29,6 +32,8 @@ */ public class ConstraintMapping { + private static final Log log = LoggerFactory.make(); + protected ConstraintMappingContext context; public ConstraintMapping() { @@ -50,9 +55,7 @@ protected ConstraintMapping(ConstraintMapping original) { */ public final TypeConstraintMappingContext type(Class beanClass) { - if ( beanClass == null ) { - throw new IllegalArgumentException( "The bean type must not be null when creating a constraint mapping." ); - } + Contracts.assertNotNull( beanClass, log.beanTypeMustNotBeNull() ); return new TypeConstraintMappingContextImpl( beanClass, context ); } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/cfg/GenericConstraintDef.java b/hibernate-validator/src/main/java/org/hibernate/validator/cfg/GenericConstraintDef.java index d363c5dc33..31df4967a7 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/cfg/GenericConstraintDef.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/cfg/GenericConstraintDef.java @@ -38,5 +38,4 @@ public GenericConstraintDef param(String key, Object value) { addParameter( key, value ); return this; } - } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ConfiguredConstraint.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ConfiguredConstraint.java index 5d3f2b89de..7d5559df49 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ConfiguredConstraint.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ConfiguredConstraint.java @@ -20,7 +20,6 @@ import java.lang.reflect.Member; import java.lang.reflect.Method; import java.util.Map; -import javax.validation.ValidationException; import org.hibernate.validator.cfg.ConstraintDef; import org.hibernate.validator.internal.metadata.location.BeanConstraintLocation; @@ -28,6 +27,8 @@ import org.hibernate.validator.internal.metadata.location.MethodConstraintLocation; import org.hibernate.validator.internal.util.annotationfactory.AnnotationDescriptor; import org.hibernate.validator.internal.util.annotationfactory.AnnotationFactory; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * Represents a programmatically configured constraint and meta-data @@ -37,6 +38,8 @@ */ public class ConfiguredConstraint { + private static final Log log = LoggerFactory.make(); + private final ConstraintDefAccessor constraint; private final L location; @@ -98,9 +101,7 @@ public A createAnnotationProxy() { return AnnotationFactory.create( annotationDescriptor ); } catch ( RuntimeException e ) { - throw new ValidationException( - "Unable to create annotation for configured constraint: " + e.getMessage(), e - ); + throw log.unableToCreateAnnotationForConfiguredConstraint( e.getMessage(), e ); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ConstraintMappingContextImplBase.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ConstraintMappingContextImplBase.java index 4e5b9fbf90..15e1d59342 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ConstraintMappingContextImplBase.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ConstraintMappingContextImplBase.java @@ -19,13 +19,14 @@ import java.lang.annotation.ElementType; import java.lang.reflect.Member; import java.lang.reflect.Method; -import javax.validation.ValidationException; import org.hibernate.validator.cfg.context.MethodConstraintMappingContext; import org.hibernate.validator.cfg.context.PropertyConstraintMappingContext; import org.hibernate.validator.cfg.context.TypeConstraintMappingContext; import org.hibernate.validator.internal.util.Contracts; import org.hibernate.validator.internal.util.ReflectionHelper; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * Base class for implementations of constraint mapping creational context types. @@ -34,8 +35,9 @@ */ public abstract class ConstraintMappingContextImplBase { - protected final Class beanClass; + private static final Log log = LoggerFactory.make(); + protected final Class beanClass; protected final ConstraintMappingContext mapping; public ConstraintMappingContextImplBase(Class beanClass, ConstraintMappingContext mapping) { @@ -46,7 +48,7 @@ public ConstraintMappingContextImplBase(Class beanClass, ConstraintMappingCon public TypeConstraintMappingContext type(Class type) { - Contracts.assertNotNull( beanClass, "The bean type must not be null when creating a constraint mapping." ); + Contracts.assertNotNull( beanClass, log.beanTypeMustNotBeNull() ); return new TypeConstraintMappingContextImpl( type, mapping ); } @@ -55,20 +57,14 @@ public PropertyConstraintMappingContext property(String property, ElementType el Contracts.assertNotNull( property, "The property name must not be null." ); Contracts.assertNotNull( elementType, "The element type must not be null." ); - - if ( property.length() == 0 ) { - throw new IllegalArgumentException( "The property name must not be empty." ); - } + Contracts.assertNotEmpty( property, log.propertyNameMustNotBeEmpty() ); Member member = ReflectionHelper.getMember( beanClass, property, elementType ); if ( member == null ) { - throw new ValidationException( - "The class " + beanClass + " does not have a property '" - + property + "' with access " + elementType - ); + throw log.unableToFindPropertyWithAccess( beanClass, property, elementType ); } return new PropertyConstraintMappingContextImpl( beanClass, member, mapping ); @@ -76,7 +72,7 @@ public PropertyConstraintMappingContext property(String property, ElementType el public MethodConstraintMappingContext method(String name, Class... parameterTypes) { - Contracts.assertNotNull( name, "The method name must not be null." ); + Contracts.assertNotNull( name, log.methodNameMustNotBeNull() ); Method method = ReflectionHelper.getDeclaredMethod( beanClass, name, parameterTypes ); @@ -88,12 +84,10 @@ public MethodConstraintMappingContext method(String name, Class... parameterT String parameterTypesAsString = sb.length() > 2 ? sb.substring( 0, sb.length() - 2 ) : sb.toString(); - throw new IllegalArgumentException( - String.format( "Type %s doesn't have a method %s(%s).", beanClass, name, parameterTypesAsString ) - ); + throw log.unableToFindMethod( beanClass, name, parameterTypesAsString ); } return new MethodConstraintMappingContextImpl( beanClass, method, mapping ); } -} \ No newline at end of file +} diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ParameterConstraintMappingContextImpl.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ParameterConstraintMappingContextImpl.java index 8af8b4f1d2..bccbe5d051 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ParameterConstraintMappingContextImpl.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/cfg/context/ParameterConstraintMappingContextImpl.java @@ -22,6 +22,8 @@ import org.hibernate.validator.cfg.context.ParameterConstraintMappingContext; import org.hibernate.validator.cfg.context.ReturnValueConstraintMappingContext; import org.hibernate.validator.internal.metadata.location.MethodConstraintLocation; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * Constraint mapping creational context which allows to configure the constraints for one method parameter. @@ -34,6 +36,8 @@ public final class ParameterConstraintMappingContextImpl extends ConstraintMappingContextImplBase implements ParameterConstraintMappingContext { + private static final Log log = LoggerFactory.make(); + private final Method method; private final int parameterIndex; @@ -42,7 +46,7 @@ public ParameterConstraintMappingContextImpl(Class beanClass, Method method, super( beanClass, mapping ); if ( parameterIndex < 0 || parameterIndex >= method.getParameterTypes().length ) { - throw new IllegalArgumentException( "A valid parameter index has to be specified for method '" + method.getName() + "'" ); + throw log.invalidMethodParameterIndex( method.getName() ); } this.method = method; diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMaxValidatorForCharSequence.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMaxValidatorForCharSequence.java index 0b50ece83d..4eea1b513f 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMaxValidatorForCharSequence.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMaxValidatorForCharSequence.java @@ -21,6 +21,9 @@ import javax.validation.ConstraintValidatorContext; import javax.validation.constraints.DecimalMax; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * Check that the character sequence (e.g. string) being validated represents a number, and has a value * less than or equal to the maximum value specified. @@ -29,6 +32,8 @@ */ public class DecimalMaxValidatorForCharSequence implements ConstraintValidator { + private static final Log log = LoggerFactory.make(); + private BigDecimal maxValue; public void initialize(DecimalMax maxValue) { @@ -36,9 +41,7 @@ public void initialize(DecimalMax maxValue) { this.maxValue = new BigDecimal( maxValue.value() ); } catch ( NumberFormatException nfe ) { - throw new IllegalArgumentException( - maxValue.value() + " does not represent a valid BigDecimal format", nfe - ); + throw log.invalidBigDecimalFormat( maxValue.value(), nfe ); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMaxValidatorForNumber.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMaxValidatorForNumber.java index 6d3d2576ad..9fedcdb8f5 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMaxValidatorForNumber.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMaxValidatorForNumber.java @@ -22,6 +22,9 @@ import javax.validation.ConstraintValidatorContext; import javax.validation.constraints.DecimalMax; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * Check that the number being validated is less than or equal to the maximum * value specified. @@ -30,6 +33,8 @@ */ public class DecimalMaxValidatorForNumber implements ConstraintValidator { + private static final Log log = LoggerFactory.make(); + private BigDecimal maxValue; public void initialize(DecimalMax maxValue) { @@ -37,9 +42,7 @@ public void initialize(DecimalMax maxValue) { this.maxValue = new BigDecimal( maxValue.value() ); } catch ( NumberFormatException nfe ) { - throw new IllegalArgumentException( - maxValue.value() + " does not represent a valid BigDecimal format", nfe - ); + throw log.invalidBigDecimalFormat( maxValue.value(), nfe ); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMinValidatorForCharSequence.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMinValidatorForCharSequence.java index 0cf4102e02..4095f820fa 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMinValidatorForCharSequence.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMinValidatorForCharSequence.java @@ -21,11 +21,16 @@ import javax.validation.ConstraintValidatorContext; import javax.validation.constraints.DecimalMin; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * @author Hardy Ferentschik */ public class DecimalMinValidatorForCharSequence implements ConstraintValidator { + private static final Log log = LoggerFactory.make(); + private BigDecimal minValue; public void initialize(DecimalMin minValue) { @@ -33,9 +38,7 @@ public void initialize(DecimalMin minValue) { this.minValue = new BigDecimal( minValue.value() ); } catch ( NumberFormatException nfe ) { - throw new IllegalArgumentException( - minValue.value() + " does not represent a valid BigDecimal format", nfe - ); + throw log.invalidBigDecimalFormat( minValue.value(), nfe ); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMinValidatorForNumber.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMinValidatorForNumber.java index e0cfd37447..39b074219c 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMinValidatorForNumber.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DecimalMinValidatorForNumber.java @@ -22,6 +22,9 @@ import javax.validation.ConstraintValidatorContext; import javax.validation.constraints.DecimalMin; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * Check that the number being validated is less than or equal to the maximum * value specified. @@ -30,6 +33,8 @@ */ public class DecimalMinValidatorForNumber implements ConstraintValidator { + private static final Log log = LoggerFactory.make(); + private BigDecimal minValue; public void initialize(DecimalMin minValue) { @@ -37,9 +42,7 @@ public void initialize(DecimalMin minValue) { this.minValue = new BigDecimal( minValue.value() ); } catch ( NumberFormatException nfe ) { - throw new IllegalArgumentException( - minValue.value() + " does not represent a valid BigDecimal format", nfe - ); + throw log.invalidBigDecimalFormat( minValue.value(), nfe ); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DigitsValidatorForCharSequence.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DigitsValidatorForCharSequence.java index c2b2c3e3da..07a2142e3d 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DigitsValidatorForCharSequence.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DigitsValidatorForCharSequence.java @@ -21,6 +21,9 @@ import javax.validation.ConstraintValidatorContext; import javax.validation.constraints.Digits; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * Validates that the character sequence (e.g. string) being validated consists of digits, * and matches the pattern defined in the constraint. @@ -30,6 +33,8 @@ */ public class DigitsValidatorForCharSequence implements ConstraintValidator { + private static final Log log = LoggerFactory.make(); + private int maxIntegerLength; private int maxFractionLength; @@ -69,10 +74,10 @@ private BigDecimal getBigDecimalValue(CharSequence charSequence) { private void validateParameters() { if ( maxIntegerLength < 0 ) { - throw new IllegalArgumentException( "The length of the integer part cannot be negative." ); + throw log.invalidLengthForIntegerPart(); } if ( maxFractionLength < 0 ) { - throw new IllegalArgumentException( "The length of the fraction part cannot be negative." ); + throw log.invalidLengthForFractionPart(); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DigitsValidatorForNumber.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DigitsValidatorForNumber.java index 5330fb3511..c4d33f3641 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DigitsValidatorForNumber.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/DigitsValidatorForNumber.java @@ -21,6 +21,9 @@ import javax.validation.ConstraintValidatorContext; import javax.validation.constraints.Digits; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * Validates that the Number being validates matches the pattern * defined in the constraint. @@ -30,6 +33,8 @@ */ public class DigitsValidatorForNumber implements ConstraintValidator { + private static final Log log = LoggerFactory.make(); + private int maxIntegerLength; private int maxFractionLength; @@ -61,10 +66,10 @@ public boolean isValid(Number num, ConstraintValidatorContext constraintValidato private void validateParameters() { if ( maxIntegerLength < 0 ) { - throw new IllegalArgumentException( "The length of the integer part cannot be negative." ); + throw log.invalidLengthForIntegerPart(); } if ( maxFractionLength < 0 ) { - throw new IllegalArgumentException( "The length of the fraction part cannot be negative." ); + throw log.invalidLengthForFractionPart(); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/LengthValidator.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/LengthValidator.java index 99745abc9f..bebc341c00 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/LengthValidator.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/LengthValidator.java @@ -20,6 +20,8 @@ import javax.validation.ConstraintValidatorContext; import org.hibernate.validator.constraints.Length; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * Check that the character sequence length is between min and max. @@ -28,6 +30,9 @@ * @author Gavin King */ public class LengthValidator implements ConstraintValidator { + + private static final Log log = LoggerFactory.make(); + private int min; private int max; @@ -47,13 +52,13 @@ public boolean isValid(CharSequence value, ConstraintValidatorContext constraint private void validateParameters() { if ( min < 0 ) { - throw new IllegalArgumentException( "The min parameter cannot be negative." ); + throw log.minCannotBeNegative(); } if ( max < 0 ) { - throw new IllegalArgumentException( "The max parameter cannot be negative." ); + throw log.maxCannotBeNegative(); } if ( max < min ) { - throw new IllegalArgumentException( "The length cannot be negative." ); + log.lengthCannotBeNegative(); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/ModCheckValidator.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/ModCheckValidator.java index 84a557e53f..decbe98aae 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/ModCheckValidator.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/ModCheckValidator.java @@ -24,6 +24,8 @@ import org.hibernate.validator.constraints.ModCheck; import org.hibernate.validator.constraints.ModCheck.ModType; import org.hibernate.validator.internal.util.ModUtil; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * Mod check validator for MOD10 and MOD11 algorithms @@ -36,6 +38,8 @@ */ public class ModCheckValidator implements ConstraintValidator { + private static final Log log = LoggerFactory.make(); + private static final String NUMBERS_ONLY_REGEXP = "[^0-9]"; private static final int DEC_RADIX = 10; @@ -75,31 +79,19 @@ public void initialize(ModCheck constraintAnnotation) { this.ignoreNonDigitCharacters = constraintAnnotation.ignoreNonDigitCharacters(); if ( this.startIndex < 0 ) { - throw new IllegalArgumentException( - String.format( "Start index cannot be negative: %d", this.startIndex ) - ); + throw log.startIndexCannotBeNegative( this.startIndex ); } if ( this.endIndex < 0 ) { - throw new IllegalArgumentException( - String.format( "End index cannot be negative: %d", this.startIndex ) - ); + throw log.endIndexCannotBeNegative( this.endIndex ); } if ( this.startIndex > this.endIndex ) { - throw new IllegalArgumentException( - String.format( "Invalid Range: %d > %d", this.startIndex, this.endIndex ) - ); + throw log.invalidRange( this.startIndex, this.endIndex ); } if ( checkDigitIndex > 0 && startIndex <= checkDigitIndex && endIndex > checkDigitIndex ) { - throw new IllegalArgumentException( - String.format( - "A explicitly specified check digit must lie outside the interval: [%d, %d]", - this.startIndex, - this.endIndex - ) - ); + throw log.invalidCheckDigit( this.startIndex, this.endIndex ); } } @@ -172,7 +164,7 @@ private List extractDigits(final String value) throws NumberFormatExcep digits.add( Character.digit( c, DEC_RADIX ) ); } else { - throw new NumberFormatException( String.format( "'%s' is not a digit", c ) ); + throw log.characterIsNotADigit( c ); } } return digits; diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/PatternValidator.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/PatternValidator.java index a5041c1173..9b9fd9cc25 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/PatternValidator.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/PatternValidator.java @@ -22,11 +22,16 @@ import javax.validation.ConstraintValidatorContext; import javax.validation.constraints.Pattern; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * @author Hardy Ferentschik */ public class PatternValidator implements ConstraintValidator { + private static final Log log = LoggerFactory.make(); + private java.util.regex.Pattern pattern; public void initialize(Pattern parameters) { @@ -40,7 +45,7 @@ public void initialize(Pattern parameters) { pattern = java.util.regex.Pattern.compile( parameters.regexp(), intFlag ); } catch ( PatternSyntaxException e ) { - throw new IllegalArgumentException( "Invalid regular expression.", e ); + throw log.invalidRegularExpression( e ); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/ScriptAssertValidator.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/ScriptAssertValidator.java index 640e284afb..f1cd6d22ed 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/ScriptAssertValidator.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/ScriptAssertValidator.java @@ -22,6 +22,9 @@ import javax.validation.ConstraintValidatorContext; import org.hibernate.validator.constraints.ScriptAssert; +import org.hibernate.validator.internal.util.Contracts; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; import org.hibernate.validator.internal.util.scriptengine.ScriptEvaluator; import org.hibernate.validator.internal.util.scriptengine.ScriptEvaluatorFactory; @@ -33,6 +36,9 @@ * @author Kevin Pollet (C) 2011 SERLI */ public class ScriptAssertValidator implements ConstraintValidator { + + private static final Log log = LoggerFactory.make(); + private String script; private String languageName; private String alias; @@ -62,18 +68,17 @@ public boolean isValid(Object value, ConstraintValidatorContext constraintValida evaluationResult = scriptEvaluator.evaluate( script, value, alias ); } catch ( ScriptException e ) { - throw new ConstraintDeclarationException( - "Error during execution of script \"" + script + "\" occurred.", e - ); + throw log.errorDuringScriptExecution( script, e ); } if ( evaluationResult == null ) { - throw new ConstraintDeclarationException( "Script \"" + script + "\" returned null, but must return either true or false." ); + throw log.scriptMustReturnTrueOrFalse( script ); } if ( !( evaluationResult instanceof Boolean ) ) { - throw new ConstraintDeclarationException( - "Script \"" + script + "\" returned " + evaluationResult + " (of type " + evaluationResult.getClass() - .getCanonicalName() + "), but must return either true or false." + throw log.scriptMustReturnTrueOrFalse( + script, + evaluationResult, + evaluationResult.getClass().getCanonicalName() ); } @@ -81,14 +86,8 @@ public boolean isValid(Object value, ConstraintValidatorContext constraintValida } private void validateParameters(ScriptAssert constraintAnnotation) { - if ( constraintAnnotation.script().length() == 0 ) { - throw new IllegalArgumentException( "The parameter \"script\" must not be empty." ); - } - if ( constraintAnnotation.lang().length() == 0 ) { - throw new IllegalArgumentException( "The parameter \"lang\" must not be empty." ); - } - if ( constraintAnnotation.alias().length() == 0 ) { - throw new IllegalArgumentException( "The parameter \"alias\" must not be empty." ); - } + Contracts.assertNotEmpty( constraintAnnotation.script(), log.parameterMustNotBeEmpty( "script" ) ); + Contracts.assertNotEmpty( constraintAnnotation.lang(), log.parameterMustNotBeEmpty( "lang" ) ); + Contracts.assertNotEmpty( constraintAnnotation.alias(), log.parameterMustNotBeEmpty( "alias" ) ); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForArray.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForArray.java index e006338cbc..820167896a 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForArray.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForArray.java @@ -21,12 +21,18 @@ import javax.validation.ConstraintValidatorContext; import javax.validation.constraints.Size; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * Check that the length of an array is between min and max * * @author Hardy Ferentschik */ public class SizeValidatorForArray implements ConstraintValidator { + + private static final Log log = LoggerFactory.make(); + private int min; private int max; @@ -56,13 +62,13 @@ public boolean isValid(Object[] array, ConstraintValidatorContext constraintVali private void validateParameters() { if ( min < 0 ) { - throw new IllegalArgumentException( "The min parameter cannot be negative." ); + throw log.minCannotBeNegative(); } if ( max < 0 ) { - throw new IllegalArgumentException( "The max parameter cannot be negative." ); + throw log.maxCannotBeNegative(); } if ( max < min ) { - throw new IllegalArgumentException( "The length cannot be negative." ); + throw log.lengthCannotBeNegative(); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForArraysOfPrimitives.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForArraysOfPrimitives.java index ccee22f77d..ebc588549b 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForArraysOfPrimitives.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForArraysOfPrimitives.java @@ -18,12 +18,18 @@ import javax.validation.constraints.Size; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * Check that the length of an array is between min and max * * @author Hardy Ferentschik */ public abstract class SizeValidatorForArraysOfPrimitives { + + private static final Log log = LoggerFactory.make(); + protected int min; protected int max; @@ -35,13 +41,13 @@ public void initialize(Size parameters) { private void validateParameters() { if ( min < 0 ) { - throw new IllegalArgumentException( "The min parameter cannot be negative." ); + throw log.minCannotBeNegative(); } if ( max < 0 ) { - throw new IllegalArgumentException( "The max parameter cannot be negative." ); + throw log.maxCannotBeNegative(); } if ( max < min ) { - throw new IllegalArgumentException( "The length cannot be negative." ); + throw log.lengthCannotBeNegative(); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForCharSequence.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForCharSequence.java index 8e522251ea..5f0ea57810 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForCharSequence.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForCharSequence.java @@ -20,6 +20,9 @@ import javax.validation.ConstraintValidatorContext; import javax.validation.constraints.Size; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * Check that the length of a character sequence is between min and max. * @@ -28,6 +31,9 @@ * @author Hardy Ferentschik */ public class SizeValidatorForCharSequence implements ConstraintValidator { + + private static final Log log = LoggerFactory.make(); + private int min; private int max; @@ -56,13 +62,13 @@ public boolean isValid(CharSequence charSequence, ConstraintValidatorContext con private void validateParameters() { if ( min < 0 ) { - throw new IllegalArgumentException( "The min parameter cannot be negative." ); + throw log.minCannotBeNegative(); } if ( max < 0 ) { - throw new IllegalArgumentException( "The max parameter cannot be negative." ); + throw log.maxCannotBeNegative(); } if ( max < min ) { - throw new IllegalArgumentException( "The length cannot be negative." ); + throw log.lengthCannotBeNegative(); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForCollection.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForCollection.java index 900c520ae0..e55da818ae 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForCollection.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForCollection.java @@ -21,12 +21,18 @@ import javax.validation.ConstraintValidatorContext; import javax.validation.constraints.Size; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * Check that a string's length is between min and max. * * @author Hardy Ferentschik */ public class SizeValidatorForCollection implements ConstraintValidator> { + + private static final Log log = LoggerFactory.make(); + private int min; private int max; @@ -56,13 +62,13 @@ public boolean isValid(Collection collection, ConstraintValidatorContext cons private void validateParameters() { if ( min < 0 ) { - throw new IllegalArgumentException( "The min parameter cannot be negative." ); + throw log.minCannotBeNegative(); } if ( max < 0 ) { - throw new IllegalArgumentException( "The max parameter cannot be negative." ); + throw log.maxCannotBeNegative(); } if ( max < min ) { - throw new IllegalArgumentException( "The length cannot be negative." ); + throw log.lengthCannotBeNegative(); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForMap.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForMap.java index b7e235497c..786eb0bd34 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForMap.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/constraintvalidators/SizeValidatorForMap.java @@ -21,12 +21,18 @@ import javax.validation.ConstraintValidatorContext; import javax.validation.constraints.Size; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * Check that a string's length is between min and max. * * @author Hardy Ferentschik */ public class SizeValidatorForMap implements ConstraintValidator> { + + private static final Log log = LoggerFactory.make(); + private int min; private int max; @@ -56,13 +62,13 @@ public boolean isValid(Map map, ConstraintValidatorContext constraintValid private void validateParameters() { if ( min < 0 ) { - throw new IllegalArgumentException( "The min parameter cannot be negative." ); + throw log.maxCannotBeNegative(); } if ( max < 0 ) { - throw new IllegalArgumentException( "The max parameter cannot be negative." ); + throw log.maxCannotBeNegative(); } if ( max < min ) { - throw new IllegalArgumentException( "The length cannot be negative." ); + throw log.lengthCannotBeNegative(); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConfigurationImpl.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConfigurationImpl.java index b0659621aa..c972026435 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConfigurationImpl.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConfigurationImpl.java @@ -24,7 +24,6 @@ import javax.validation.ConstraintValidatorFactory; import javax.validation.MessageInterpolator; import javax.validation.TraversableResolver; -import javax.validation.ValidationException; import javax.validation.ValidationProviderResolver; import javax.validation.ValidatorFactory; import javax.validation.spi.BootstrapState; @@ -35,6 +34,7 @@ import org.hibernate.validator.cfg.ConstraintMapping; import org.hibernate.validator.internal.engine.resolver.DefaultTraversableResolver; import org.hibernate.validator.internal.util.CollectionHelper; +import org.hibernate.validator.internal.util.Contracts; import org.hibernate.validator.internal.util.Version; import org.hibernate.validator.internal.util.logging.Log; import org.hibernate.validator.internal.util.logging.LoggerFactory; @@ -88,7 +88,7 @@ public ConfigurationImpl(BootstrapState state) { public ConfigurationImpl(ValidationProvider provider) { if ( provider == null ) { - throw new ValidationException( "Assertion error: inconsistent ConfigurationImpl construction" ); + throw log.inconsistentConfiguration(); } this.providerResolver = null; validationBootstrapParameters = new ValidationBootstrapParameters(); @@ -134,9 +134,9 @@ public final ConfigurationImpl constraintValidatorFactory(ConstraintValidatorFac } public final HibernateValidatorConfiguration addMapping(InputStream stream) { - if ( stream == null ) { - throw new IllegalArgumentException( "The stream cannot be null." ); - } + + Contracts.assertNotNull( stream, log.parameterMustNotBeNull( "stream" ) ); + validationBootstrapParameters.addMapping( stream ); return this; } @@ -147,10 +147,9 @@ public final HibernateValidatorConfiguration failFast(boolean failFast) { } public final HibernateValidatorConfiguration addMapping(ConstraintMapping mapping) { - if ( mapping == null ) { - throw new IllegalArgumentException( "The mapping cannot be null." ); - } - this.programmaticMappings.add( mapping ); + Contracts.assertNotNull( mapping, log.parameterMustNotBeNull( "mapping" ) ); + + this.programmaticMappings.add(mapping); return this; } @@ -178,7 +177,7 @@ public final ValidatorFactory buildValidatorFactory() { } } if ( factory == null ) { - throw new ValidationException( "Unable to find provider: " + providerClass ); + throw log.unableToFindProvider( providerClass ); } } else { diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConstraintTree.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConstraintTree.java index 1ffaf189f8..b947d6564c 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConstraintTree.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConstraintTree.java @@ -28,8 +28,6 @@ import javax.validation.ConstraintValidator; import javax.validation.ConstraintValidatorFactory; import javax.validation.ConstraintViolation; -import javax.validation.UnexpectedTypeException; -import javax.validation.ValidationException; import javax.validation.metadata.ConstraintDescriptor; import org.hibernate.validator.constraints.CompositionType; @@ -284,7 +282,7 @@ private > Set validateSingleConstra isValid = validator.isValid( valueContext.getCurrentValidatedValue(), constraintValidatorContext ); } catch ( RuntimeException e ) { - throw new ValidationException( "Unexpected exception during isValid call", e ); + throw log.exceptionDuringIsValidCall( e ); } if ( !isValid ) { //We do not add them these violations yet, since we don't know how they are @@ -343,9 +341,7 @@ private ConstraintValidator createAndInitializeValidator(ConstraintVal validatorClass ); if ( constraintValidator == null ) { - throw new ValidationException( - "Constraint factory returned null when trying to create instance of " + validatorClass.getName() - ); + throw log.constraintFactoryMustNotReturnNull( validatorClass.getName() ); } initializeConstraint( descriptor, constraintValidator ); return constraintValidator; @@ -384,19 +380,16 @@ private void verifyResolveWasUnique(Type valueClass, List assignableClasse className = clazz.getName(); } } - throw new UnexpectedTypeException( "No validator could be found for type: " + className ); + throw log.noValidatorFoundForType( className ); } else if ( assignableClasses.size() > 1 ) { StringBuilder builder = new StringBuilder(); - builder.append( "There are multiple validator classes which could validate the type " ); - builder.append( valueClass ); - builder.append( ". The validator classes are: " ); for ( Type clazz : assignableClasses ) { builder.append( clazz ); builder.append( ", " ); } builder.delete( builder.length() - 2, builder.length() ); - throw new UnexpectedTypeException( builder.toString() ); + throw log.moreThanOneValidatorFoundForType( valueClass, builder.toString() ); } } @@ -446,7 +439,7 @@ else if ( TypeHelper.isAssignable( assignableTypes.get( i ), type ) ) { constraintValidator.initialize( descriptor.getAnnotation() ); } catch ( RuntimeException e ) { - throw new ValidationException( "Unable to initialize " + constraintValidator.getClass().getName(), e ); + throw log.unableToInitializeConstraintValidator( constraintValidator.getClass().getName(), e ); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConstraintValidatorContextImpl.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConstraintValidatorContextImpl.java index ceefe9cce9..41e22f5368 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConstraintValidatorContextImpl.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ConstraintValidatorContextImpl.java @@ -19,14 +19,18 @@ import java.util.ArrayList; import java.util.List; import javax.validation.ConstraintValidatorContext; -import javax.validation.ValidationException; import javax.validation.metadata.ConstraintDescriptor; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * @author Hardy Ferentschik */ public class ConstraintValidatorContextImpl implements ConstraintValidatorContext { + private static final Log log = LoggerFactory.make(); + private final List messageAndPaths = new ArrayList( 3 ); private final PathImpl basePath; private final ConstraintDescriptor constraintDescriptor; @@ -56,9 +60,7 @@ public final ConstraintDescriptor getConstraintDescriptor() { public final List getMessageAndPathList() { if ( defaultDisabled && messageAndPaths.size() == 0 ) { - throw new ValidationException( - "At least one custom message must be created if the default error message gets disabled." - ); + throw log.atLeastOneCustomMessageMustBeCreated(); } List returnedMessageAndPaths = new ArrayList( messageAndPaths ); diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/PathImpl.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/PathImpl.java index 1728c47bd0..e5e6987369 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/PathImpl.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/PathImpl.java @@ -27,6 +27,8 @@ import javax.validation.Path; import org.hibernate.validator.internal.util.Contracts; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * @author Hardy Ferentschik @@ -36,6 +38,7 @@ public final class PathImpl implements Path, Serializable { private static final long serialVersionUID = 7564511574909882392L; + private static final Log log = LoggerFactory.make(); public static final String PROPERTY_PATH_SEPARATOR = "."; @@ -71,9 +74,8 @@ public final class PathImpl implements Path, Serializable { * {@code property} cannot be parsed. */ public static PathImpl createPathFromString(String propertyPath) { - if ( propertyPath == null ) { - throw new IllegalArgumentException( "null is not allowed as property path." ); - } + + Contracts.assertNotNull( propertyPath, log.propertyPathCannotBeNull() ); if ( propertyPath.length() == 0 ) { return createNewPath( null ); @@ -291,7 +293,7 @@ private static PathImpl parseProperty(String property) { String value = matcher.group( PROPERTY_NAME_GROUP ); if ( !isValidJavaIdentifier( value ) ) { - throw new IllegalArgumentException( value + " is not a valid Java Identifier" ); + throw log.invalidJavaIdentifier( value ); } // create the node @@ -318,7 +320,7 @@ private static PathImpl parseProperty(String property) { tmp = matcher.group( REMAINING_STRING_GROUP ); } else { - throw new IllegalArgumentException( "Unable to parse property path " + property ); + throw log.unableToParsePropertyPath( property ); } } while ( tmp != null ); diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValidatorFactoryImpl.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValidatorFactoryImpl.java index c084055ed4..670d5bb219 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValidatorFactoryImpl.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValidatorFactoryImpl.java @@ -20,7 +20,6 @@ import javax.validation.ConstraintValidatorFactory; import javax.validation.MessageInterpolator; import javax.validation.TraversableResolver; -import javax.validation.ValidationException; import javax.validation.Validator; import javax.validation.spi.ConfigurationState; @@ -32,6 +31,8 @@ import org.hibernate.validator.internal.metadata.provider.MetaDataProvider; import org.hibernate.validator.internal.metadata.provider.ProgrammaticMappingMetaDataProvider; import org.hibernate.validator.internal.metadata.provider.XmlConfigurationMetaDataProvider; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; import static org.hibernate.validator.internal.util.CollectionHelper.newArrayList; @@ -46,6 +47,8 @@ */ public class ValidatorFactoryImpl implements HibernateValidatorFactory { + private static final Log log = LoggerFactory.make(); + private final MessageInterpolator messageInterpolator; private final TraversableResolver traversableResolver; private final ConstraintValidatorFactory constraintValidatorFactory; @@ -115,7 +118,7 @@ public T unwrap(Class type) { if ( HibernateValidatorFactory.class.equals( type ) ) { return type.cast( this ); } - throw new ValidationException( "Type " + type + " not supported" ); + throw log.typeNotSupported( type ); } public HibernateValidatorContext usingContext() { @@ -134,10 +137,7 @@ private boolean checkPropertiesForFailFast(ConfigurationState configurationState if ( failFastPropValue != null ) { boolean tmpFailFast = Boolean.valueOf( failFastPropValue ); if ( programmaticConfiguredFailFast && !tmpFailFast ) { - throw new ValidationException( - "Inconsistent fail fast configuration. Fail fast enabled via programmatic API, " + - "but explicitly disabled via properties" - ); + throw log.inconsistentFailFastConfiguration(); } failFast = tmpFailFast; } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValidatorImpl.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValidatorImpl.java index ae3fd0c9fa..c1d7200c7f 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValidatorImpl.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValidatorImpl.java @@ -32,7 +32,6 @@ import javax.validation.MessageInterpolator; import javax.validation.Path; import javax.validation.TraversableResolver; -import javax.validation.ValidationException; import javax.validation.Validator; import javax.validation.groups.Default; import javax.validation.metadata.BeanDescriptor; @@ -49,6 +48,8 @@ import org.hibernate.validator.internal.util.Contracts; import org.hibernate.validator.internal.util.ReflectionHelper; import org.hibernate.validator.internal.util.TypeHelper; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; import org.hibernate.validator.method.MethodConstraintViolation; import org.hibernate.validator.method.MethodValidator; import org.hibernate.validator.method.metadata.TypeDescriptor; @@ -66,6 +67,8 @@ */ public class ValidatorImpl implements Validator, MethodValidator { + private static final Log log = LoggerFactory.make(); + /** * The default group array used in case any of the validate methods is called without a group. */ @@ -114,9 +117,8 @@ public ValidatorImpl(ConstraintValidatorFactory constraintValidatorFactory, Mess } public final Set> validate(T object, Class... groups) { - if ( object == null ) { - throw new IllegalArgumentException( "Validation of a null object" ); - } + + Contracts.assertNotNull( object, log.validatedObjectMustNotBeNull() ); GroupChain groupChain = determineGroupExecutionOrder( groups ); @@ -130,9 +132,9 @@ object, messageInterpolator, constraintValidatorFactory, getCachingTraversableRe } public final Set> validateProperty(T object, String propertyName, Class... groups) { - if ( object == null ) { - throw new IllegalArgumentException( "Validated object cannot be null." ); - } + + Contracts.assertNotNull( object, log.validatedObjectMustNotBeNull() ); + sanityCheckPropertyPath( propertyName ); GroupChain groupChain = determineGroupExecutionOrder( groups ); @@ -148,9 +150,8 @@ public final Set> validateProperty(T object, String p } public final Set> validateValue(Class beanType, String propertyName, Object value, Class... groups) { - if ( beanType == null ) { - throw new IllegalArgumentException( "The bean type cannot be null." ); - } + + Contracts.assertNotNull( beanType, log.beanTypeCannotBeNull() ); sanityCheckPropertyPath( propertyName ); GroupChain groupChain = determineGroupExecutionOrder( groups ); @@ -168,8 +169,8 @@ public final Set> validateValue(Class beanType, St public final Set> validateParameter(T object, Method method, Object parameterValue, int parameterIndex, Class... groups) { - Contracts.assertNotNull( object, "The object to be validated must not be null" ); - Contracts.assertNotNull( method, "The method to be validated must not be null" ); + Contracts.assertNotNull( object, log.validatedObjectMustNotBeNull() ); + Contracts.assertNotNull( method, log.validatedMethodMustNotBeNull() ); GroupChain groupChain = determineGroupExecutionOrder( groups ); @@ -193,8 +194,8 @@ public final Set> validateParameter(T object, M public final Set> validateAllParameters(T object, Method method, Object[] parameterValues, Class... groups) { - Contracts.assertNotNull( object, "The object to be validated must not be null" ); - Contracts.assertNotNull( method, "The method to be validated must not be null" ); + Contracts.assertNotNull( object, log.validatedObjectMustNotBeNull() ); + Contracts.assertNotNull( method, log.validatedMethodMustNotBeNull() ); //this might be the case for parameterless methods if ( parameterValues == null ) { @@ -219,7 +220,7 @@ public final Set> validateAllParameters(T objec public Set> validateReturnValue(T object, Method method, Object returnValue, Class... groups) { - Contracts.assertNotNull( method, "The method to be validated must not be null" ); + Contracts.assertNotNull( method, log.validatedMethodMustNotBeNull() ); GroupChain groupChain = determineGroupExecutionOrder( groups ); @@ -249,20 +250,18 @@ public final T unwrap(Class type) { if ( type.isAssignableFrom( getClass() ) ) { return type.cast( this ); } - - throw new ValidationException( "Type " + type + " not supported" ); + throw log.typeNotSupported( type ); } private void sanityCheckPropertyPath(String propertyName) { if ( propertyName == null || propertyName.length() == 0 ) { - throw new IllegalArgumentException( "Invalid property path." ); + throw log.invalidPropertyPath(); } } private GroupChain determineGroupExecutionOrder(Class[] groups) { - if ( groups == null ) { - throw new IllegalArgumentException( "null passed as group name" ); - } + + Contracts.assertNotNull( groups, log.groupMustNotBeNull() ); Class[] tmpGroups = groups; // if no groups is specified use the default @@ -622,7 +621,7 @@ private Set> validatePropertyInContext(Validati ); if ( valueContext.getCurrentBean() == null ) { - throw new IllegalArgumentException( "Invalid property path." ); + throw log.invalidPropertyPath(); } if ( metaConstraints.size() == 0 ) { @@ -1138,10 +1137,7 @@ private ValueContext collectMetaConstraintsForPath(Class claz BeanMetaData metaData = beanMetaDataManager.getBeanMetaData( clazz ); //use precomputed method list as ReflectionHelper#containsMember is slow if ( !metaData.isPropertyPresent( elem.getName() ) ) { - throw new IllegalArgumentException( - "Invalid property path. There is no property " + elem.getName() + " in entity " - + metaData.getBeanClass().getName() - ); + throw log.invalidPropertyPath( elem.getName(), metaData.getBeanClass().getName() ); } if ( !propertyIter.hasNext() ) { @@ -1169,7 +1165,7 @@ else if ( newValue != null && elem.getKey() != null ) { newValue = ReflectionHelper.getMappedValue( newValue, elem.getKey() ); } else if ( newValue != null ) { - throw new IllegalArgumentException( "Property path must provide index or map key" ); + throw log.propertyPathMustProvideIndexOrMapKey(); } type = ReflectionHelper.getIndexedType( type ); } @@ -1230,7 +1226,7 @@ private boolean isValidationRequired(ValidationContext validationContext, ); } catch ( RuntimeException e ) { - throw new ValidationException( "Call to TraversableResolver.isReachable() threw an exception", e ); + throw log.errorDuringCallOfTraversableResolverIsReachable( e ); } return isReachable; @@ -1259,7 +1255,7 @@ private boolean isCascadeRequired(ValidationContext validationContext, Val ); } catch ( RuntimeException e ) { - throw new ValidationException( "Call to TraversableResolver.isReachable() threw an exception", e ); + throw log.errorDuringCallOfTraversableResolverIsReachable( e ); } } @@ -1277,7 +1273,7 @@ private boolean isCascadeRequired(ValidationContext validationContext, Val ); } catch ( RuntimeException e ) { - throw new ValidationException( "Call to TraversableResolver.isCascadable() threw an exception", e ); + throw log.errorDuringCallOfTraversableResolverIsCascadable( e ); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValueContext.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValueContext.java index 4d411d372f..ee3bb0dd16 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValueContext.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/ValueContext.java @@ -20,6 +20,10 @@ import java.lang.reflect.Type; import javax.validation.groups.Default; +import org.hibernate.validator.internal.util.Contracts; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * An instance of this class is used to collect all the relevant information for validating a single class, property or * method invocation. @@ -29,6 +33,8 @@ */ public class ValueContext { + private static final Log log = LoggerFactory.make(); + /** * The current bean which gets validated. This is the bean hosting the constraints which get validated. */ @@ -161,13 +167,11 @@ public final void setPropertyPath(PathImpl propertyPath) { * @param node the name of the new node. Cannot be {@code null}. */ public final void appendNode(String node) { - if ( node == null ) { - throw new IllegalArgumentException(); - } - else { - propertyPath = PathImpl.createCopy( propertyPath ); - propertyPath.addNode( node ); - } + + Contracts.assertNotNull( node, log.mustNotBeNull( "node" ) ); + + propertyPath = PathImpl.createCopy( propertyPath ); + propertyPath.addNode( node ); } public final void markCurrentPropertyAsIterable() { diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/groups/GroupChain.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/groups/GroupChain.java index bf1f573c35..6205ab0751 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/groups/GroupChain.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/groups/GroupChain.java @@ -21,9 +21,11 @@ import java.util.Iterator; import java.util.List; import java.util.Map; -import javax.validation.GroupDefinitionException; import javax.validation.groups.Default; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * An instance of {@code GroupChain} defines the group order during one full validation call. * @@ -31,6 +33,8 @@ */ public final class GroupChain { + private static final Log log = LoggerFactory.make(); + /** * The list of single groups to be used this validation. */ @@ -102,7 +106,7 @@ private void ensureDefaultGroupSequenceIsExpandable(List groupList, List< // since we basically have two groups continue; } - throw new GroupDefinitionException( "Unable to expand default group list" + defaultGroupList + " into sequence " + groupList ); + throw log.unableToExpandDefaultGroupList( defaultGroupList, groupList ); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/groups/GroupChainGenerator.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/groups/GroupChainGenerator.java index eb627fcdc2..f948575d2c 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/groups/GroupChainGenerator.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/engine/groups/GroupChainGenerator.java @@ -21,9 +21,10 @@ import java.util.List; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; -import javax.validation.GroupDefinitionException; import javax.validation.GroupSequence; -import javax.validation.ValidationException; + +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * Helper class used to resolve groups and sequences into a single chain of groups which can then be validated. @@ -33,6 +34,8 @@ */ public class GroupChainGenerator { + private static final Log log = LoggerFactory.make(); + private final ConcurrentMap, List> resolvedSequences = new ConcurrentHashMap, List>(); /** @@ -44,12 +47,12 @@ public class GroupChainGenerator { */ public GroupChain getGroupChainFor(Collection> groups) { if ( groups == null || groups.size() == 0 ) { - throw new IllegalArgumentException( "At least one groups has to be specified." ); + throw log.atLeastOneGroupHasToBeSpecified(); } for ( Class clazz : groups ) { if ( !clazz.isInterface() ) { - throw new ValidationException( "A group has to be an interface. " + clazz.getName() + " is not." ); + throw log.groupHasToBeAnInterface( clazz.getName() ); } } @@ -114,9 +117,7 @@ private List expandInheritedGroups(List sequence) { private void addInheritedGroups(Group group, List expandedGroups) { for ( Class inheritedGroup : group.getGroup().getInterfaces() ) { if ( isGroupSequence( inheritedGroup ) ) { - throw new GroupDefinitionException( - "Sequence definitions are not allowed as composing parts of a sequence." - ); + throw log.sequenceDefinitionsNotAllowed(); } Group g = new Group( inheritedGroup, group.getSequence() ); expandedGroups.add( g ); @@ -126,7 +127,7 @@ private void addInheritedGroups(Group group, List expandedGroups) { private List resolveSequence(Class group, List> processedSequences) { if ( processedSequences.contains( group ) ) { - throw new GroupDefinitionException( "Cyclic dependency in groups definition" ); + throw log.cyclicDependencyInGroupsDefinition(); } else { processedSequences.add( group ); @@ -152,7 +153,7 @@ private void addGroups(List resolvedGroupSequence, List groups) { for ( Group tmpGroup : groups ) { if ( resolvedGroupSequence.contains( tmpGroup ) && resolvedGroupSequence.indexOf( tmpGroup ) < resolvedGroupSequence .size() - 1 ) { - throw new GroupDefinitionException( "Unable to expand group sequence." ); + throw log.unableToExpandGroupSequence(); } resolvedGroupSequence.add( tmpGroup ); } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/BeanMetaDataCache.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/BeanMetaDataCache.java index ab8a57f3c9..e61523a7e4 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/BeanMetaDataCache.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/BeanMetaDataCache.java @@ -21,6 +21,8 @@ import org.hibernate.validator.internal.metadata.aggregated.BeanMetaData; import org.hibernate.validator.internal.metadata.aggregated.BeanMetaDataImpl; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; import static org.hibernate.validator.internal.util.Contracts.assertNotNull; @@ -31,6 +33,9 @@ * @author Kevin Pollet (C) 2011 SERLI */ public class BeanMetaDataCache { + + private static final Log log = LoggerFactory.make(); + /** * A map for the meta data for each entity. The key is the class and the value the bean meta data for this * entity. @@ -41,15 +46,15 @@ public class BeanMetaDataCache { @SuppressWarnings("unchecked") public BeanMetaData getBeanMetaData(Class beanClass) { - assertNotNull( beanClass, "Class cannot be null" ); + assertNotNull( beanClass, log.mustNotBeNull( "Class" ) ); return (BeanMetaDataImpl) metadataProviders.get( beanClass ); } @SuppressWarnings("unchecked") public BeanMetaData addBeanMetaData(Class beanClass, BeanMetaData metaData) { - assertNotNull( beanClass, "Class cannot be null" ); - assertNotNull( metaData, "MetaData cannot be null" ); + assertNotNull( beanClass, log.mustNotBeNull( "Class" ) ); + assertNotNull( metaData, log.mustNotBeNull( "MetaData" ) ); return (BeanMetaData) metadataProviders.putIfAbsent( beanClass, metaData ); } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/aggregated/BeanMetaDataImpl.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/aggregated/BeanMetaDataImpl.java index 1cdf88f2f8..925e5c072e 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/aggregated/BeanMetaDataImpl.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/aggregated/BeanMetaDataImpl.java @@ -27,7 +27,6 @@ import java.util.Map; import java.util.Map.Entry; import java.util.Set; -import javax.validation.GroupDefinitionException; import javax.validation.groups.Default; import javax.validation.metadata.BeanDescriptor; import javax.validation.metadata.PropertyDescriptor; @@ -302,9 +301,7 @@ private Map getMethodsAsDescriptors() { private void setDefaultGroupSequenceOrProvider(List> defaultGroupSequence, Class> defaultGroupSequenceProvider) { if ( defaultGroupSequence != null && defaultGroupSequenceProvider != null ) { - throw new GroupDefinitionException( - "Default group sequence and default group sequence provider cannot be defined at the same time." - ); + throw log.invalidDefaultGroupSequenceDefinition(); } if ( defaultGroupSequenceProvider != null ) { @@ -378,7 +375,7 @@ private List> getValidDefaultGroupSequence(List> groupSequence groupSequenceContainsDefault = true; } else if ( group.getName().equals( Default.class.getName() ) ) { - throw new GroupDefinitionException( "'Default.class' cannot appear in default group sequence list." ); + throw log.noDefaultGroupInGroupSequence(); } else { validDefaultGroupSequence.add( group ); @@ -386,7 +383,7 @@ else if ( group.getName().equals( Default.class.getName() ) ) { } } if ( !groupSequenceContainsDefault ) { - throw new GroupDefinitionException( beanClass.getName() + " must be part of the redefined default group sequence." ); + throw log.beanClassMustBePartOfRedefinedDefaultGroupSequence( beanClass.getName() ); } if ( log.isTraceEnabled() ) { log.tracef( @@ -417,9 +414,7 @@ private > DefaultGroupSequenceProvider } } - throw new GroupDefinitionException( - "The default group sequence provider defined for " + beanClass.getName() + " has the wrong type" - ); + throw log.wrongDefaultGroupSequenceProviderType( beanClass.getName() ); } private Partitioner> byElementType() { diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/aggregated/MethodMetaData.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/aggregated/MethodMetaData.java index 47eb1379f7..11dbda257c 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/aggregated/MethodMetaData.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/aggregated/MethodMetaData.java @@ -31,9 +31,11 @@ import org.hibernate.validator.internal.metadata.raw.ConstrainedElement.ConstrainedElementKind; import org.hibernate.validator.internal.metadata.raw.ConstrainedMethod; import org.hibernate.validator.internal.metadata.raw.ConstrainedParameter; +import org.hibernate.validator.internal.util.ReflectionHelper; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; import org.hibernate.validator.method.metadata.MethodDescriptor; import org.hibernate.validator.method.metadata.ParameterDescriptor; -import org.hibernate.validator.internal.util.ReflectionHelper; import static org.hibernate.validator.internal.util.CollectionHelper.newArrayList; import static org.hibernate.validator.internal.util.CollectionHelper.newHashSet; @@ -59,8 +61,9 @@ */ public class MethodMetaData extends AbstractConstraintMetaData { - private final Class[] parameterTypes; + private static final Log log = LoggerFactory.make(); + private final Class[] parameterTypes; private final List parameterMetaData; /** @@ -329,7 +332,7 @@ public void assertCorrectnessOfMethodParameterConstraints() throws ConstraintDec public ParameterMetaData getParameterMetaData(int parameterIndex) { if ( parameterIndex < 0 || parameterIndex > parameterMetaData.size() - 1 ) { - throw new IllegalArgumentException( "Method " + getName() + " doesn't have a parameter with index " + parameterIndex ); + throw log.invalidMethodParameterIndex( getName(), parameterIndex ); } return parameterMetaData.get( parameterIndex ); diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/core/ConstraintHelper.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/core/ConstraintHelper.java index c7280157a2..f4648ac3df 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/core/ConstraintHelper.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/core/ConstraintHelper.java @@ -22,7 +22,6 @@ import java.util.List; import java.util.concurrent.ConcurrentHashMap; import javax.validation.Constraint; -import javax.validation.ConstraintDefinitionException; import javax.validation.ConstraintValidator; import javax.validation.ValidationException; import javax.validation.constraints.AssertFalse; @@ -88,7 +87,10 @@ import org.hibernate.validator.internal.constraintvalidators.SizeValidatorForCollection; import org.hibernate.validator.internal.constraintvalidators.SizeValidatorForMap; import org.hibernate.validator.internal.constraintvalidators.URLValidator; +import org.hibernate.validator.internal.util.Contracts; import org.hibernate.validator.internal.util.ReflectionHelper; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; import static org.hibernate.validator.internal.util.CollectionHelper.newArrayList; @@ -101,6 +103,8 @@ */ public class ConstraintHelper { + private static final Log log = LoggerFactory.make(); + private static final String JODA_TIME_CLASS_NAME = "org.joda.time.ReadableInstant"; private final ConcurrentHashMap, List>>> builtinConstraints = @@ -220,7 +224,7 @@ public ConstraintHelper() { final List>> builtInList = builtinConstraints.get( annotationClass ); if ( builtInList == null || builtInList.size() == 0 ) { - throw new ValidationException( "Unable to find constraints for " + annotationClass ); + throw log.unableToFindAnnotationConstraints( annotationClass ); } List>> constraints = newArrayList( builtInList.size() ); @@ -332,8 +336,7 @@ private void assertNoParameterStartsWithValid(Class annota final Method[] methods = ReflectionHelper.getDeclaredMethods( annotationType ); for ( Method m : methods ) { if ( m.getName().startsWith( "valid" ) ) { - String msg = "Parameters starting with 'valid' are not allowed in a constraint."; - throw new ConstraintDefinitionException( msg ); + throw log.constraintParametersCannotStartWithValid(); } } } @@ -342,22 +345,15 @@ private void assertPayloadParameterExists(Class annotation try { final Method method = ReflectionHelper.getMethod( annotationType, "payload" ); if ( method == null ) { - String msg = annotationType.getName() + " contains Constraint annotation, but does " + - "not contain a payload parameter."; - throw new ConstraintDefinitionException( msg ); + throw log.constraintWithoutMandatoryParameter( "payload", annotationType.getName() ); } Class[] defaultPayload = (Class[]) method.getDefaultValue(); if ( defaultPayload.length != 0 ) { - String msg = annotationType - .getName() + " contains Constraint annotation, but the payload " + - "parameter default value is not the empty array."; - throw new ConstraintDefinitionException( msg ); + throw log.wrongDefaultValueForPayloadParameter( annotationType.getName() ); } } catch ( ClassCastException e ) { - String msg = annotationType.getName() + " contains Constraint annotation, but the " + - "payload parameter is of wrong type."; - throw new ConstraintDefinitionException( msg, e ); + throw log.wrongTypeForPayloadParameter( annotationType.getName(), e ); } } @@ -365,51 +361,32 @@ private void assertGroupsParameterExists(Class annotationT try { final Method method = ReflectionHelper.getMethod( annotationType, "groups" ); if ( method == null ) { - String msg = annotationType.getName() + " contains Constraint annotation, but does " + - "not contain a groups parameter."; - throw new ConstraintDefinitionException( msg ); + throw log.constraintWithoutMandatoryParameter( "groups", annotationType.getName() ); } Class[] defaultGroups = (Class[]) method.getDefaultValue(); if ( defaultGroups.length != 0 ) { - String msg = annotationType - .getName() + " contains Constraint annotation, but the groups " + - "parameter default value is not the empty array."; - throw new ConstraintDefinitionException( msg ); + throw log.wrongDefaultValueForGroupsParameter( annotationType.getName() ); } } catch ( ClassCastException e ) { - String msg = annotationType.getName() + " contains Constraint annotation, but the " + - "groups parameter is of wrong type."; - throw new ConstraintDefinitionException( msg, e ); + throw log.wrongTypeForGroupsParameter( annotationType.getName(), e ); } } private void assertMessageParameterExists(Class annotationType) { - try { - final Method method = ReflectionHelper.getMethod( annotationType, "message" ); - if ( method == null ) { - String msg = annotationType.getName() + " contains Constraint annotation, but does " + - "not contain a message parameter."; - throw new ConstraintDefinitionException( msg ); - } - if ( method.getReturnType() != String.class ) { - String msg = annotationType.getName() + " contains Constraint annotation, but the message parameter " + - "is not of type java.lang.String."; - throw new ConstraintDefinitionException( msg ); - } + final Method method = ReflectionHelper.getMethod( annotationType, "message" ); + if ( method == null ) { + throw log.constraintWithoutMandatoryParameter( "message", annotationType.getName() ); } - catch ( ClassCastException e ) { - String msg = annotationType.getName() + " contains Constraint annotation, but the " + - "groups parameter is of wrong type."; - throw new ConstraintDefinitionException( msg, e ); + if ( method.getReturnType() != String.class ) { + throw log.wrongTypeForMessageParameter( annotationType.getName() ); } } public List>> getConstraintValidatorDefinition (Class annotationClass) { - if ( annotationClass == null ) { - throw new IllegalArgumentException( "Class cannot be null" ); - } + + Contracts.assertNotNull( annotationClass, log.classCannotBeNull() ); final List>> list = constraintValidatorDefinitions.get( annotationClass diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/descriptor/BeanDescriptorImpl.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/descriptor/BeanDescriptorImpl.java index c1a0ece45b..1ec864f77d 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/descriptor/BeanDescriptorImpl.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/descriptor/BeanDescriptorImpl.java @@ -26,10 +26,12 @@ import javax.validation.metadata.BeanDescriptor; import javax.validation.metadata.PropertyDescriptor; +import org.hibernate.validator.internal.util.Contracts; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; import org.hibernate.validator.method.metadata.MethodDescriptor; import org.hibernate.validator.method.metadata.ParameterDescriptor; import org.hibernate.validator.method.metadata.TypeDescriptor; -import org.hibernate.validator.internal.util.Contracts; import static org.hibernate.validator.internal.util.CollectionHelper.newHashSet; import static org.hibernate.validator.internal.util.Contracts.assertNotNull; @@ -43,10 +45,10 @@ */ public class BeanDescriptorImpl extends ElementDescriptorImpl implements BeanDescriptor, TypeDescriptor { - private final Map constrainedProperties; + private static final Log log = LoggerFactory.make(); + private final Map constrainedProperties; private final Map methods; - private final Set constrainedMethods; public BeanDescriptorImpl(Class beanClass, Set> classLevelConstraints, Map properties, Map methods, boolean defaultGroupSequenceRedefined, List> defaultGroupSequence) { @@ -88,7 +90,7 @@ public Set getConstrainedMethods() { //a descriptor if the given method is constrained. public MethodDescriptor getConstraintsForMethod(String methodName, Class... parameterTypes) { - Contracts.assertNotNull( methodName, "The method name must not be null" ); + Contracts.assertNotNull( methodName, log.methodNameMustNotBeNull() ); return methods.get( methodName + Arrays.toString( parameterTypes ) ); } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/descriptor/ConstraintDescriptorImpl.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/descriptor/ConstraintDescriptorImpl.java index 8e0c442e27..b9d1133a19 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/descriptor/ConstraintDescriptorImpl.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/descriptor/ConstraintDescriptorImpl.java @@ -33,7 +33,6 @@ import java.util.Map; import java.util.Set; import javax.validation.Constraint; -import javax.validation.ConstraintDefinitionException; import javax.validation.ConstraintValidator; import javax.validation.OverridesAttribute; import javax.validation.Payload; @@ -323,10 +322,10 @@ private Map buildAnnotationParameterMap(Annotation annotation) { parameters.put( m.getName(), m.invoke( annotation ) ); } catch ( IllegalAccessException e ) { - throw new ValidationException( "Unable to read annotation attributes: " + annotation.getClass(), e ); + throw log.unableToReadAnnotationAttributes( annotation.getClass(), e ); } catch ( InvocationTargetException e ) { - throw new ValidationException( "Unable to read annotation attributes: " + annotation.getClass(), e ); + throw log.unableToReadAnnotationAttributes( annotation.getClass(), e ); } } return Collections.unmodifiableMap( parameters ); @@ -339,10 +338,10 @@ private Object getMethodValue(Annotation annotation, Method m) { } // should never happen catch ( IllegalAccessException e ) { - throw new ValidationException( "Unable to retrieve annotation parameter value.", e ); + throw log.unableToRetrieveAnnotationParameterValue( e ); } catch ( InvocationTargetException e ) { - throw new ValidationException( "Unable to retrieve annotation parameter value.", e ); + throw log.unableToRetrieveAnnotationParameterValue( e ); } return value; } @@ -388,15 +387,14 @@ private void addOverrideAttributes(Map> o private void ensureAttributeIsOverridable(Method m, OverridesAttribute overridesAttribute) { final Method method = ReflectionHelper.getMethod( overridesAttribute.constraint(), overridesAttribute.name() ); if ( method == null ) { - throw new ConstraintDefinitionException( - "Overridden constraint does not define an attribute with name " + overridesAttribute.name() - ); + throw log.overriddenConstraintAttributeNotFound( overridesAttribute.name() ); } Class returnTypeOfOverriddenConstraint = method.getReturnType(); if ( !returnTypeOfOverriddenConstraint.equals( m.getReturnType() ) ) { - String message = "The overriding type of a composite constraint must be identical to the overridden one. Expected " + returnTypeOfOverriddenConstraint - .getName() + " found " + m.getReturnType(); - throw new ConstraintDefinitionException( message ); + throw log.wrongAttributeTypeForOverriddenConstraint( + returnTypeOfOverriddenConstraint.getName(), + m.getReturnType() + ); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/location/MethodConstraintLocation.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/location/MethodConstraintLocation.java index 9e47980e9c..59bf30e571 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/location/MethodConstraintLocation.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/location/MethodConstraintLocation.java @@ -22,6 +22,8 @@ import org.hibernate.validator.internal.util.Contracts; import org.hibernate.validator.internal.util.ReflectionHelper; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * A {@link ConstraintLocation} implementation that represents a method @@ -31,13 +33,14 @@ */ public class MethodConstraintLocation implements ConstraintLocation { - private final Method method; + private static final Log log = LoggerFactory.make(); + private final Method method; private final Integer parameterIndex; public MethodConstraintLocation(Method method) { - Contracts.assertNotNull( method, "Method must not be null" ); + Contracts.assertNotNull( method, log.mustNotBeNull( "Method" ) ); this.method = method; this.parameterIndex = null; @@ -51,7 +54,7 @@ public MethodConstraintLocation(Method method) { */ public MethodConstraintLocation(Method method, int parameterIndex) { - Contracts.assertNotNull( method, "Method must not be null" ); + Contracts.assertNotNull( method, log.mustNotBeNull( "Method" ) ); this.method = method; this.parameterIndex = parameterIndex; diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/provider/ProgrammaticMappingMetaDataProvider.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/provider/ProgrammaticMappingMetaDataProvider.java index a2ed93cd62..eb8cbf38fa 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/provider/ProgrammaticMappingMetaDataProvider.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/provider/ProgrammaticMappingMetaDataProvider.java @@ -24,7 +24,6 @@ import java.util.List; import java.util.Map; import java.util.Set; -import javax.validation.GroupDefinitionException; import org.hibernate.validator.cfg.ConstraintMapping; import org.hibernate.validator.internal.cfg.context.ConfiguredConstraint; @@ -45,6 +44,8 @@ import org.hibernate.validator.internal.metadata.raw.ConstrainedType; import org.hibernate.validator.internal.util.CollectionHelper.Partitioner; import org.hibernate.validator.internal.util.Contracts; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; import static org.hibernate.validator.internal.util.CollectionHelper.newArrayList; import static org.hibernate.validator.internal.util.CollectionHelper.newHashSet; @@ -57,6 +58,8 @@ */ public class ProgrammaticMappingMetaDataProvider extends MetaDataProviderImplBase { + private static final Log log = LoggerFactory.make(); + public ProgrammaticMappingMetaDataProvider(ConstraintHelper constraintHelper, Set programmaticMappings) { super( constraintHelper ); Contracts.assertNotNull( programmaticMappings ); @@ -308,7 +311,7 @@ private void mergeGroupSequenceAndGroupSequenceProvider(ConstraintMappingContext for ( Class clazz : context.getConfiguredClasses() ) { if ( context.getDefaultGroupSequenceProvider( clazz ) != null ) { if ( mergedContext.getDefaultGroupSequenceProvider( clazz ) != null ) { - throw new GroupDefinitionException( "Multiple definitions of default group sequence provider" ); + throw log.multipleDefinitionOfDefaultGroupSequenceProvider(); } mergedContext.addDefaultGroupSequenceProvider( clazz, @@ -318,7 +321,7 @@ private void mergeGroupSequenceAndGroupSequenceProvider(ConstraintMappingContext if ( context.getDefaultSequence( clazz ) != null ) { if ( mergedContext.getDefaultSequence( clazz ) != null ) { - throw new GroupDefinitionException( "Multiple definitions of default group sequence" ); + throw log.multipleDefinitionOfDefaultGroupSequence(); } mergedContext.addDefaultGroupSequence( clazz, diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/raw/ConstrainedMethod.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/raw/ConstrainedMethod.java index 34170214af..b63684742a 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/raw/ConstrainedMethod.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/metadata/raw/ConstrainedMethod.java @@ -24,6 +24,8 @@ import org.hibernate.validator.internal.metadata.core.MetaConstraint; import org.hibernate.validator.internal.metadata.location.MethodConstraintLocation; import org.hibernate.validator.internal.util.ReflectionHelper; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * Represents a method of a Java type and all its associated meta-data relevant @@ -34,6 +36,8 @@ */ public class ConstrainedMethod extends AbstractConstrainedElement { + private static final Log log = LoggerFactory.make(); + /** * Constrained-related meta data for this method's parameters. */ @@ -98,11 +102,10 @@ public ConstrainedMethod( Method method = location.getMember(); if ( parameterMetaData.size() != method.getParameterTypes().length ) { - throw new IllegalArgumentException( - String.format( - "Method %s has %s parameters, but the passed list of parameter meta data has a size of %s.", - method, method.getParameterTypes().length, parameterMetaData.size() - ) + throw log.invalidLengthOfParameterMetaDataList( + method, + method.getParameterTypes().length, + parameterMetaData.size() ); } @@ -144,7 +147,7 @@ public MethodConstraintLocation getLocation() { public ConstrainedParameter getParameterMetaData(int parameterIndex) { if ( parameterIndex < 0 || parameterIndex > parameterMetaData.size() - 1 ) { - throw new IllegalArgumentException( "Method " + getLocation().getMember() + " doesn't have a parameter with index " + parameterIndex ); + throw log.invalidMethodParameterIndex( getLocation().getMember().getName(), parameterIndex ); } return parameterMetaData.get( parameterIndex ); diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/Contracts.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/Contracts.java index 9c5fea4185..8ab876ec94 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/Contracts.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/Contracts.java @@ -16,6 +16,9 @@ */ package org.hibernate.validator.internal.util; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * @author Gunnar Morling * @author Hardy Ferentschik @@ -23,11 +26,13 @@ */ public final class Contracts { + private static final Log log = LoggerFactory.make(); + private Contracts() { } public static void assertNotNull(Object o) { - assertNotNull( o, "must not be null" ); + assertNotNull( o, log.mustNotBeNull() ); } public static void assertNotNull(Object o, String message) { @@ -41,4 +46,10 @@ public static void assertTrue(boolean condition, String message) { throw new IllegalArgumentException( message ); } } + + public static void assertNotEmpty(String s, String message) { + if ( s.length() == 0 ) { + throw new IllegalArgumentException( message ); + } + } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/LazyValidatorFactory.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/LazyValidatorFactory.java index be09f4157a..6e269af76f 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/LazyValidatorFactory.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/LazyValidatorFactory.java @@ -175,14 +175,10 @@ private List> instantiateProviders(List providerNa providers.add( (ValidationProvider) providerClass.newInstance() ); } catch ( IllegalAccessException e ) { - throw new ValidationException( - "Unable to instantiate Bean Validation provider" + providerNames, e - ); + throw log.unableToInstantiateBeanValidationProvider( providerNames, e ); } catch ( InstantiationException e ) { - throw new ValidationException( - "Unable to instantiate Bean Validation provider" + providerNames, e - ); + throw log.unableToInstantiateBeanValidationProvider( providerNames, e ); } } return providers; @@ -212,7 +208,7 @@ private List loadProviderNamesFromServiceFile(ClassLoader classloader) { } } catch ( IOException e ) { - throw new ValidationException( "Unable to read " + SERVICES_FILE, e ); + throw log.unableToReadServicesFile( SERVICES_FILE, e ); } // we want to make sure that Hibernate Validator is in the list and on the first position. This diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/ReflectionHelper.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/ReflectionHelper.java index 2715c49933..e778d3ee2f 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/ReflectionHelper.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/ReflectionHelper.java @@ -36,8 +36,9 @@ import java.util.List; import java.util.Map; import java.util.Set; -import javax.validation.ValidationException; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; import org.hibernate.validator.internal.util.privilegedactions.ConstructorInstance; import org.hibernate.validator.internal.util.privilegedactions.GetAnnotationParameter; import org.hibernate.validator.internal.util.privilegedactions.GetClassLoader; @@ -62,6 +63,9 @@ * @author Kevin Pollet (C) 2011 SERLI */ public final class ReflectionHelper { + + private static final Log log = LoggerFactory.make(); + private static String[] PROPERTY_ACCESSOR_PREFIXES = { "is", "get", "has" }; /** @@ -214,16 +218,15 @@ public static boolean propertyExists(Class clazz, String property, ElementTyp * @return the member which matching the name and type or {@code null} if no such member exists. */ public static Member getMember(Class clazz, String property, ElementType elementType) { - if ( clazz == null ) { - throw new IllegalArgumentException( "The class cannot be null" ); - } + + Contracts.assertNotNull( clazz, log.classCannotBeNull() ); if ( property == null || property.length() == 0 ) { - throw new IllegalArgumentException( "Property name cannot be null or empty" ); + throw log.propertyNameCannotBeNullOrEmpty(); } if ( !( ElementType.FIELD.equals( elementType ) || ElementType.METHOD.equals( elementType ) ) ) { - throw new IllegalArgumentException( "Element type has to be FIELD or METHOD" ); + throw log.elementTypeHasToBeFieldOrMethod(); } Member member = null; @@ -289,7 +292,7 @@ else if ( member instanceof Method ) { type = ( (Method) member ).getGenericReturnType(); } else { - throw new IllegalArgumentException( "Member " + member + " is neither a field nor a method" ); + throw log.memberIsNeitherAFieldNorAMethod( member ); } if ( type instanceof TypeVariable ) { type = TypeHelper.getErasedType( type ); @@ -325,10 +328,10 @@ public static Object getValue(Member member, Object object) { value = method.invoke( object ); } catch ( IllegalAccessException e ) { - throw new ValidationException( "Unable to access " + method.getName(), e ); + throw log.unableToAccessMember( method.getName(), e ); } catch ( InvocationTargetException e ) { - throw new ValidationException( "Unable to access " + method.getName(), e ); + throw log.unableToAccessMember( method.getName(), e ); } } else if ( member instanceof Field ) { @@ -337,7 +340,7 @@ else if ( member instanceof Field ) { value = field.get( object ); } catch ( IllegalAccessException e ) { - throw new ValidationException( "Unable to access " + field.getName(), e ); + throw log.unableToAccessMember( field.getName(), e ); } } return value; @@ -669,9 +672,8 @@ public static Method[] getMethods(Class clazz) { */ public static boolean haveSameSignature(Method method1, Method method2) { - if ( method1 == null || method2 == null ) { - throw new IllegalArgumentException( "method1 and method2 must not be null" ); - } + Contracts.assertNotNull( method1, log.mustNotBeNull( "method1" ) ); + Contracts.assertNotNull( method2, log.mustNotBeNull( "method2" ) ); return method1.getName().equals( method2.getName() ) && @@ -689,7 +691,7 @@ public static boolean haveSameSignature(Method method1, Method method2) { */ public static Class boxedType(Type primitiveType) { if ( !( primitiveType instanceof Class ) && !( (Class) primitiveType ).isPrimitive() ) { - throw new IllegalArgumentException( primitiveType.getClass() + "has to be a primitive type" ); + throw log.hasToBeAPrimitiveType( primitiveType.getClass() ); } if ( primitiveType == boolean.class ) { @@ -717,7 +719,7 @@ else if ( primitiveType == byte.class ) { return Byte.class; } else { - throw new RuntimeException( "Unhandled primitive type." ); + throw log.unhandledPrimitiveType(); } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/TypeHelper.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/TypeHelper.java index e94155985b..58bbe61954 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/TypeHelper.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/TypeHelper.java @@ -35,7 +35,9 @@ import java.util.Map.Entry; import java.util.Set; import javax.validation.ConstraintValidator; -import javax.validation.ValidationException; + +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * Provides utility methods for working with types. @@ -46,6 +48,7 @@ public final class TypeHelper { private static final Map, Set>> SUBTYPES_BY_PRIMITIVE; private static final int VALIDATOR_TYPE_INDEX = 1; + private static final Log log = LoggerFactory.make(); static { Map, Set>> subtypesByPrimitive = new HashMap, Set>>(); @@ -303,7 +306,7 @@ private static Type extractType(Class> valid //we now have all bind from a type to its resolution at one level Type validatorType = ( (ParameterizedType) constraintValidatorType ).getActualTypeArguments()[VALIDATOR_TYPE_INDEX]; if ( validatorType == null ) { - throw new ValidationException( "null is an invalid type for a constraint validator." ); + throw log.nullIsAnInvalidTypeForAConstraintValidator(); } else if ( validatorType instanceof GenericArrayType ) { validatorType = TypeHelper.getArrayType( TypeHelper.getComponentType( validatorType ) ); @@ -575,7 +578,7 @@ private static ParameterizedType parameterizeClassCapture(Class type, Map Type actualTypeArgument = actualTypeArgumentsByParameter.get( typeParameter ); if ( actualTypeArgument == null ) { - throw new IllegalArgumentException( "Missing actual type argument for type parameter: " + typeParameter ); + throw log.missingActualTypeArgumentForTypeParameter( typeParameter ); } actualTypeArguments[i] = actualTypeArgument; diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/annotationfactory/AnnotationProxy.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/annotationfactory/AnnotationProxy.java index 7b0b52cd51..377815789b 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/annotationfactory/AnnotationProxy.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/annotationfactory/AnnotationProxy.java @@ -27,7 +27,8 @@ import java.util.TreeSet; import org.hibernate.validator.internal.util.ReflectionHelper; - +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * A concrete implementation of Annotation that pretends it is a @@ -56,10 +57,11 @@ public class AnnotationProxy implements Annotation, InvocationHandler, Serializable { private static final long serialVersionUID = 6907601010599429454L; + private static final Log log = LoggerFactory.make(); + private final Class annotationType; private final Map values; - public AnnotationProxy(AnnotationDescriptor descriptor) { this.annotationType = descriptor.type(); values = getAnnotationValues( descriptor ); @@ -78,7 +80,7 @@ else if ( m.getDefaultValue() != null ) { result.put( m.getName(), m.getDefaultValue() ); } else { - throw new IllegalArgumentException( "No value provided for " + m.getName() ); + throw log.noValueProvidedForAnnotationParameter( m.getName() ); } } if ( processedValuesFromDescriptor != descriptor.numberOfElements() ) { @@ -86,7 +88,7 @@ else if ( m.getDefaultValue() != null ) { Set unknownParameters = descriptor.getElements().keySet(); unknownParameters.removeAll( result.keySet() ); - throw new RuntimeException( "Trying to instantiate " + annotationType + " with unknown parameter(s): " + unknownParameters ); + throw log.tryingToInstantiateAnnotationWithUnknownParameters( annotationType, unknownParameters ); } return result; } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/logging/Log.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/logging/Log.java index cf08e37d5d..dcc0be3afa 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/logging/Log.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/logging/Log.java @@ -16,7 +16,26 @@ */ package org.hibernate.validator.internal.util.logging; +import java.lang.annotation.Annotation; +import java.lang.annotation.ElementType; +import java.lang.reflect.Member; +import java.lang.reflect.Method; +import java.lang.reflect.Type; +import java.lang.reflect.TypeVariable; +import java.util.IllegalFormatException; +import java.util.List; +import java.util.Set; +import java.util.regex.PatternSyntaxException; +import javax.script.ScriptException; +import javax.validation.ConstraintDeclarationException; +import javax.validation.ConstraintDefinitionException; +import javax.validation.GroupDefinitionException; +import javax.validation.UnexpectedTypeException; +import javax.validation.ValidationException; +import javax.xml.bind.JAXBException; + import org.jboss.logging.BasicLogger; +import org.jboss.logging.Cause; import org.jboss.logging.LogMessage; import org.jboss.logging.Message; import org.jboss.logging.MessageLogger; @@ -75,4 +94,380 @@ public interface Log extends BasicLogger { @LogMessage(level = WARN) @Message(id = 11, value = "Unable to create schema for %1$s: %2$s") void unableToCreateSchema(String fileName, String message); + + @Message(id = 12, value = "Unable to create annotation for configured constraint: %s.") + ValidationException unableToCreateAnnotationForConfiguredConstraint(String message, @Cause RuntimeException e); + + @Message(id = 13, value = "The class %1$s does not have a property '%2$s' with access %3$s.") + ValidationException unableToFindPropertyWithAccess(Class beanClass, String property, ElementType elementType); + + @Message(id = 14, value = "Type %1$s doesn't have a method %2$s(%3$s).") + IllegalArgumentException unableToFindMethod(Class beanClass, String name, String parametersType); + + @Message(id = 15, value = "A valid parameter index has to be specified for method '%s'") + IllegalArgumentException invalidMethodParameterIndex(String methodName); + + @Message(id = 16, value = "%s does not represent a valid BigDecimal format.") + IllegalArgumentException invalidBigDecimalFormat(String value, @Cause NumberFormatException e); + + @Message(id = 17, value = "The length of the integer part cannot be negative.") + IllegalArgumentException invalidLengthForIntegerPart(); + + @Message(id = 18, value = "The length of the fraction part cannot be negative.") + IllegalArgumentException invalidLengthForFractionPart(); + + @Message(id = 19, value = "The min parameter cannot be negative.") + IllegalArgumentException minCannotBeNegative(); + + @Message(id = 20, value = "The max parameter cannot be negative.") + IllegalArgumentException maxCannotBeNegative(); + + @Message(id = 21, value = "The length cannot be negative.") + IllegalArgumentException lengthCannotBeNegative(); + + @Message(id = 22, value = "Invalid regular expression.") + IllegalArgumentException invalidRegularExpression(@Cause PatternSyntaxException e); + + @Message(id = 23, value = "Error during execution of script \"%s\" occurred.") + ConstraintDeclarationException errorDuringScriptExecution(String script, @Cause ScriptException e); + + @Message(id = 24, value = "Script \"%s\" returned null, but must return either true or false.") + ConstraintDeclarationException scriptMustReturnTrueOrFalse(String script); + + @Message(id = 25, value = "Script \"%1$s\" returned %2$s (of type %3$s), but must return either true or false.") + ConstraintDeclarationException scriptMustReturnTrueOrFalse(String script, Object executionResult, String type); + + @Message(id = 26, value = "Assertion error: inconsistent ConfigurationImpl construction.") + ValidationException inconsistentConfiguration(); + + @Message(id = 27, value = "Unable to find provider: %s.") + ValidationException unableToFindProvider(Class providerClass); + + @Message(id = 28, value = "Unexpected exception during isValid call.") + ValidationException exceptionDuringIsValidCall(@Cause RuntimeException e); + + @Message(id = 29, value = "Constraint factory returned null when trying to create instance of %s.") + ValidationException constraintFactoryMustNotReturnNull(String validatorClassName); + + @Message(id = 30, value = "No validator could be found for type: %s.") + UnexpectedTypeException noValidatorFoundForType(String className); + + @Message(id = 31, + value = "There are multiple validator classes which could validate the type %1$s. The validator classes are: %2$s.") + UnexpectedTypeException moreThanOneValidatorFoundForType(Type type, String validatorClasses); + + @Message(id = 32, value = "Unable to initialize %s.") + ValidationException unableToInitializeConstraintValidator(String validatorClassName, @Cause RuntimeException e); + + @Message(id = 33, value = "At least one custom message must be created if the default error message gets disabled.") + ValidationException atLeastOneCustomMessageMustBeCreated(); + + @Message(id = 34, value = "%s is not a valid Java Identifier.") + IllegalArgumentException invalidJavaIdentifier(String identifier); + + @Message(id = 35, value = "Unable to parse property path %s.") + IllegalArgumentException unableToParsePropertyPath(String propertyPath); + + @Message(id = 36, value = "Type %s not supported.") + ValidationException typeNotSupported(Class type); + + @Message(id = 37, + value = "Inconsistent fail fast configuration. Fail fast enabled via programmatic API, but explicitly disabled via properties.") + ValidationException inconsistentFailFastConfiguration(); + + @Message(id = 38, value = "Invalid property path.") + IllegalArgumentException invalidPropertyPath(); + + @Message(id = 39, value = "Invalid property path. There is no property %1$s in entity %2$s.") + IllegalArgumentException invalidPropertyPath(String propertyName, String beanClassName); + + @Message(id = 40, value = "Property path must provide index or map key.") + IllegalArgumentException propertyPathMustProvideIndexOrMapKey(); + + @Message(id = 41, value = "Call to TraversableResolver.isReachable() threw an exception.") + ValidationException errorDuringCallOfTraversableResolverIsReachable(@Cause RuntimeException e); + + @Message(id = 42, value = "Call to TraversableResolver.isCascadable() threw an exception.") + ValidationException errorDuringCallOfTraversableResolverIsCascadable(@Cause RuntimeException e); + + @Message(id = 43, value = "Unable to expand default group list %1$s into sequence %2$s.") + GroupDefinitionException unableToExpandDefaultGroupList(List defaultGroupList, List groupList); + + @Message(id = 44, value = "At least one group has to be specified.") + IllegalArgumentException atLeastOneGroupHasToBeSpecified(); + + @Message(id = 45, value = "A group has to be an interface. %s is not.") + ValidationException groupHasToBeAnInterface(String className); + + @Message(id = 46, value = "Sequence definitions are not allowed as composing parts of a sequence.") + GroupDefinitionException sequenceDefinitionsNotAllowed(); + + @Message(id = 47, value = "Cyclic dependency in groups definition") + GroupDefinitionException cyclicDependencyInGroupsDefinition(); + + @Message(id = 48, value = "Unable to expand group sequence.") + GroupDefinitionException unableToExpandGroupSequence(); + + @Message(id = 49, value = "The given index must be between %1$s and %2$s.") + IndexOutOfBoundsException invalidIndex(String lowerBound, String upperBound); + + @Message(id = 50, value = "Missing format string in template: %s.") + ValidationException missingFormatStringInTemplate(String expression); + + @Message(id = 51, value = "Invalid format: %s.") + ValidationException invalidFormat(String message, @Cause IllegalFormatException e); + + @Message(id = 52, + value = "Default group sequence and default group sequence provider cannot be defined at the same time.") + GroupDefinitionException invalidDefaultGroupSequenceDefinition(); + + @Message(id = 53, value = "'Default.class' cannot appear in default group sequence list.") + GroupDefinitionException noDefaultGroupInGroupSequence(); + + @Message(id = 54, value = "%s must be part of the redefined default group sequence.") + GroupDefinitionException beanClassMustBePartOfRedefinedDefaultGroupSequence(String beanClassName); + + @Message(id = 55, value = "The default group sequence provider defined for %s has the wrong type") + GroupDefinitionException wrongDefaultGroupSequenceProviderType(String beanClassName); + + @Message(id = 56, value = "Method %1$s doesn't have a parameter with index %2$d.") + IllegalArgumentException invalidMethodParameterIndex(String method, int index); + + @Message(id = 57, value = "Unable to find constraints for %s.") + ValidationException unableToFindAnnotationConstraints(Class annotationClass); + + @Message(id = 58, value = "Unable to read annotation attributes: %s.") + ValidationException unableToReadAnnotationAttributes(Class annotationClass, @Cause Exception e); + + @Message(id = 59, value = "Unable to retrieve annotation parameter value.") + ValidationException unableToRetrieveAnnotationParameterValue(@Cause Exception e); + + @Message(id = 60, value = "Multiple definitions of default group sequence provider.") + GroupDefinitionException multipleDefinitionOfDefaultGroupSequenceProvider(); + + @Message(id = 61, value = "Multiple definitions of default group sequence.") + GroupDefinitionException multipleDefinitionOfDefaultGroupSequence(); + + @Message(id = 62, + value = "Method %1$s has %2$s parameters, but the passed list of parameter meta data has a size of %3$s.") + IllegalArgumentException invalidLengthOfParameterMetaDataList(Method method, int nbParameters, int listSize); + + @Message(id = 63, value = "Unable to instantiate %s.") + ValidationException unableToInstantiate(String className, @Cause Exception e); + + ValidationException unableToInstantiate(Class clazz, @Cause Exception e); + + @Message(id = 64, value = "Unable to instantiate %1$s: %2$s.") + ValidationException unableToInstantiate(String message, Class clazz, @Cause Exception e); + + @Message(id = 65, value = "Unable to load class: %s.") + ValidationException unableToLoadClass(String className); + + ValidationException unableToLoadClass(String className, @Cause Exception e); + + @Message(id = 66, value = "Unable to instantiate Bean Validation provider %s.") + ValidationException unableToInstantiateBeanValidationProvider(List providerName, @Cause Exception e); + + @Message(id = 67, value = "Unable to read %s.") + ValidationException unableToReadServicesFile(String servicesFileName, @Cause Exception e); + + @Message(id = 68, value = "No JSR 223 script engine found for language \"%s\".") + ScriptException unableToFindScriptEngine(String languageName); + + @Message(id = 69, value = "Start index cannot be negative: %d.") + IllegalArgumentException startIndexCannotBeNegative(int startIndex); + + @Message(id = 70, value = "End index cannot be negative: %d.") + IllegalArgumentException endIndexCannotBeNegative(int endIndex); + + @Message(id = 71, value = "Invalid Range: %1$d > %2$d.") + IllegalArgumentException invalidRange(int startIndex, int endIndex); + + @Message(id = 72, value = "A explicitly specified check digit must lie outside the interval: [%1$d, %2$d].") + IllegalArgumentException invalidCheckDigit(int startIndex, int endIndex); + + @Message(id = 73, value = "'%c' is not a digit.") + NumberFormatException characterIsNotADigit(char c); + + @Message(id = 74, value = "Parameters starting with 'valid' are not allowed in a constraint.") + ConstraintDefinitionException constraintParametersCannotStartWithValid(); + + @Message(id = 75, value = "%2$s contains Constraint annotation, but does not contain a %1$s parameter.") + ConstraintDefinitionException constraintWithoutMandatoryParameter(String parameterName, String constraintName); + + @Message(id = 76, + value = "%s contains Constraint annotation, but the payload parameter default value is not the empty array.") + ConstraintDefinitionException wrongDefaultValueForPayloadParameter(String constraintName); + + @Message(id = 77, value = "%s contains Constraint annotation, but the payload parameter is of wrong type.") + ConstraintDefinitionException wrongTypeForPayloadParameter(String constraintName, @Cause ClassCastException e); + + @Message(id = 78, + value = "%s contains Constraint annotation, but the groups parameter default value is not the empty array.") + ConstraintDefinitionException wrongDefaultValueForGroupsParameter(String constraintName); + + @Message(id = 79, value = "%s contains Constraint annotation, but the groups parameter is of wrong type.") + ConstraintDefinitionException wrongTypeForGroupsParameter(String constraintName, @Cause ClassCastException e); + + @Message(id = 80, + value = "%s contains Constraint annotation, but the message parameter is not of type java.lang.String.") + ConstraintDefinitionException wrongTypeForMessageParameter(String constraintName); + + @Message(id = 81, value = "Overridden constraint does not define an attribute with name %s.") + ConstraintDefinitionException overriddenConstraintAttributeNotFound(String attributeName); + + @Message(id = 82, + value = "The overriding type of a composite constraint must be identical to the overridden one. Expected %1$s found %2$s.") + ConstraintDefinitionException wrongAttributeTypeForOverriddenConstraint(String expectedReturnType, Class currentReturnType); + + @Message(id = 83, value = "Wrong parameter type. Expected: %1$s Actual: %2$s.") + ValidationException wrongParameterType(String expectedType, String currentType); + + @Message(id = 84, value = "The specified annotation defines no parameter '%s'.") + ValidationException unableToFindAnnotationParameter(String parameterName, @Cause NoSuchMethodException e); + + @Message(id = 85, value = "Unable to get '%1$s' from %2$s.") + ValidationException unableToGetAnnotationParameter(String parameterName, String annotationName, @Cause Exception e); + + @Message(id = 86, value = "No value provided for %s.") + IllegalArgumentException noValueProvidedForAnnotationParameter(String parameterName); + + @Message(id = 87, value = "Trying to instantiate %1$s with unknown parameter(s): %2$s.") + RuntimeException tryingToInstantiateAnnotationWithUnknownParameters(Class annotationType, Set unknownParameters); + + @Message(id = 88, value = "Property name cannot be null or empty.") + IllegalArgumentException propertyNameCannotBeNullOrEmpty(); + + @Message(id = 89, value = "Element type has to be FIELD or METHOD.") + IllegalArgumentException elementTypeHasToBeFieldOrMethod(); + + @Message(id = 90, value = "Member %s is neither a field nor a method.") + IllegalArgumentException memberIsNeitherAFieldNorAMethod(Member member); + + @Message(id = 91, value = "Unable to access %s.") + ValidationException unableToAccessMember(String memberName, @Cause Exception e); + + @Message(id = 92, value = "%s has to be a primitive type.") + IllegalArgumentException hasToBeAPrimitiveType(Class clazz); + + @Message(id = 93, value = "Unhandled primitive type.") + RuntimeException unhandledPrimitiveType(); + + @Message(id = 94, value = "null is an invalid type for a constraint validator.") + ValidationException nullIsAnInvalidTypeForAConstraintValidator(); + + @Message(id = 95, value = "Missing actual type argument for type parameter: %s.") + IllegalArgumentException missingActualTypeArgumentForTypeParameter(TypeVariable typeParameter); + + @Message(id = 96, value = "Unable to instantiate constraint factory class %s.") + ValidationException unableToInstantiateConstraintFactoryClass(String constraintFactoryClassName, @Cause ValidationException e); + + @Message(id = 97, value = "Unable to open input stream for mapping file %s.") + ValidationException unableToOpenInputStreamForMappingFile(String mappingFileName); + + @Message(id = 98, value = "Unable to instantiate message interpolator class %s.") + ValidationException unableToInstantiateMessageInterpolatorClass(String messageInterpolatorClassName, @Cause Exception e); + + @Message(id = 99, value = "Unable to instantiate traversable resolver class %s.") + ValidationException unableToInstantiateTraversableResolverClass(String traversableResolverClassName, @Cause Exception e); + + @Message(id = 100, value = "Unable to instantiate validation provider class %s.") + ValidationException unableToInstantiateValidationProviderClass(String providerClassName, @Cause Exception e); + + @Message(id = 101, value = "Unable to parse %s.") + ValidationException unableToParseValidationXmlFile(String file, @Cause JAXBException e); + + @Message(id = 102, value = "%s is not an annotation.") + ValidationException isNotAnAnnotation(String annotationClassName); + + @Message(id = 103, value = "%s is not a constraint validator class.") + ValidationException isNotAConstraintValidatorClass(Class validatorClass); + + @Message(id = 104, value = "%s has already be configured in xml.") + ValidationException beanClassHasAlreadyBeConfiguredInXml(String beanClassName); + + @Message(id = 105, value = "%1$s is defined twice in mapping xml for bean %2$s.") + ValidationException isDefinedTwiceInMappingXmlForBean(String name, String beanClassName); + + @Message(id = 106, value = "%1$s does not contain the fieldType %2$s.") + ValidationException beanDoesNotContainTheField(String beanClassName, String fieldName); + + @Message(id = 107, value = "%1$s does not contain the property %2$s.") + ValidationException beanDoesNotContainTheProperty(String beanClassName, String getterName); + + @Message(id = 108, value = "Annotation of type %1$s does not contain a parameter %2$s.") + ValidationException annotationDoesNotContainAParameter(String annotationClassName, String parameterName); + + @Message(id = 109, value = "Attempt to specify an array where single value is expected.") + ValidationException attemptToSpecifyAnArrayWhereSingleValueIsExpected(); + + @Message(id = 110, value = "Unexpected parameter value.") + ValidationException unexpectedParameterValue(); + + ValidationException unexpectedParameterValue(@Cause ClassCastException e); + + @Message(id = 111, value = "Invalid %s format.") + ValidationException invalidNumberFormat(String formatName, @Cause NumberFormatException e); + + @Message(id = 112, value = "Invalid char value: %s.") + ValidationException invalidCharValue(String value); + + @Message(id = 113, value = "Invalid return type: %s. Should be a enumeration type.") + ValidationException invalidReturnType(Class returnType, @Cause ClassCastException e); + + @Message(id = 114, value = "%s, %s, %s are reserved parameter names.") + ValidationException reservedParameterNames(String messageParameterName, String groupsParameterName, String payloadParameterName); + + @Message(id = 115, value = "Specified payload class %s does not implement javax.validation.Payload") + ValidationException wrongPayloadClass(String payloadClassName); + + @Message(id = 116, value = "Error parsing mapping file.") + ValidationException errorParsingMappingFile(@Cause JAXBException e); + + /** + * The following lines are not a logging statement or an exception factory declaration but these messages have to be + * internationalized. + */ + + @Message(value = "must not be null.") + String mustNotBeNull(); + + @Message(value = "%s must not be null.") + String mustNotBeNull(String parameterName); + + @Message(value = "The parameter \"%s\" must not be null.") + String parameterMustNotBeNull(String parameterName); + + @Message(value = "The parameter \"%s\" must not be empty.") + String parameterMustNotBeEmpty(String parameterName); + + @Message(value = "The bean type cannot be null.") + String beanTypeCannotBeNull(); + + @Message(value = "null is not allowed as property path.") + String propertyPathCannotBeNull(); + + @Message(value = "The property name must not be empty.") + String propertyNameMustNotBeEmpty(); + + @Message(value = "null passed as group name.") + String groupMustNotBeNull(); + + @Message(value = "The bean type must not be null when creating a constraint mapping.") + String beanTypeMustNotBeNull(); + + @Message(value = "The method name must not be null.") + String methodNameMustNotBeNull(); + + @Message(value = "The object to be validated must not be null.") + String validatedObjectMustNotBeNull(); + + @Message(value = "The method to be validated must not be null.") + String validatedMethodMustNotBeNull(); + + @Message(value = "The class cannot be null.") + String classCannotBeNull(); + + @Message(value = "Class is null.") + String classIsNull(); } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/ConstructorInstance.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/ConstructorInstance.java index 3247697fe0..5af18c63ba 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/ConstructorInstance.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/ConstructorInstance.java @@ -21,7 +21,9 @@ import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.security.PrivilegedAction; -import javax.validation.ValidationException; + +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * Execute instance creation as privileged action. @@ -30,6 +32,9 @@ * @author Hardy Ferentschik */ public final class ConstructorInstance implements PrivilegedAction { + + private static final Log log = LoggerFactory.make(); + private final Constructor constructor; private final Object[] initArgs; @@ -47,16 +52,16 @@ public T run() { return constructor.newInstance( initArgs ); } catch ( InstantiationException e ) { - throw new ValidationException( "Unable to instantiate" + constructor.getName(), e ); + throw log.unableToInstantiate( constructor.getName(), e ); } catch ( IllegalAccessException e ) { - throw new ValidationException( "Unable to instantiate" + constructor.getName(), e ); + throw log.unableToInstantiate( constructor.getName(), e ); } catch ( InvocationTargetException e ) { - throw new ValidationException( "Unable to instantiate" + constructor.getName(), e ); + throw log.unableToInstantiate( constructor.getName(), e ); } catch ( RuntimeException e ) { - throw new ValidationException( "Unable to instantiate" + constructor.getName(), e ); + throw log.unableToInstantiate( constructor.getName(), e ); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/GetAnnotationParameter.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/GetAnnotationParameter.java index 332950846a..72bcd547ae 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/GetAnnotationParameter.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/GetAnnotationParameter.java @@ -20,18 +20,22 @@ import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.security.PrivilegedAction; -import javax.validation.ValidationException; + +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * @author Emmanuel Bernard * @author Hardy Ferentschik */ public final class GetAnnotationParameter implements PrivilegedAction { + + private static final Log log = LoggerFactory.make(); + private final Annotation annotation; private final String parameterName; private final Class type; - public static GetAnnotationParameter action(Annotation annotation, String parameterName, Class type) { return new GetAnnotationParameter( annotation, parameterName, type ); } @@ -51,21 +55,17 @@ public T run() { return ( T ) o; } else { - String msg = "Wrong parameter type. Expected: " + type.getName() + " Actual: " + o.getClass().getName(); - throw new ValidationException( msg ); + throw log.wrongParameterType( type.getName(), o.getClass().getName() ); } } catch ( NoSuchMethodException e ) { - String msg = "The specified annotation defines no parameter '" + parameterName + "'."; - throw new ValidationException( msg, e ); + throw log.unableToFindAnnotationParameter( parameterName, e ); } catch ( IllegalAccessException e ) { - String msg = "Unable to get '" + parameterName + "' from " + annotation.getClass().getName(); - throw new ValidationException( msg, e ); + throw log.unableToGetAnnotationParameter( parameterName, annotation.getClass().getName(), e ); } catch ( InvocationTargetException e ) { - String msg = "Unable to get '" + parameterName + "' from " + annotation.getClass().getName(); - throw new ValidationException( msg, e ); + throw log.unableToGetAnnotationParameter( parameterName, annotation.getClass().getName(), e ); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/GetClassLoader.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/GetClassLoader.java index 3948632cf1..2894506344 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/GetClassLoader.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/GetClassLoader.java @@ -18,10 +18,17 @@ import java.security.PrivilegedAction; +import org.hibernate.validator.internal.util.Contracts; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * @author Emmanuel Bernard */ public final class GetClassLoader implements PrivilegedAction { + + private static final Log log = LoggerFactory.make(); + private final Class clazz; public static GetClassLoader fromContext() { @@ -29,9 +36,7 @@ public static GetClassLoader fromContext() { } public static GetClassLoader fromClass(Class clazz) { - if ( clazz == null ) { - throw new IllegalArgumentException( "Class is null" ); - } + Contracts.assertNotNull( clazz, log.classIsNull() ); return new GetClassLoader( clazz ); } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/LoadClass.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/LoadClass.java index ef6dd2d110..6e62ddb963 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/LoadClass.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/LoadClass.java @@ -17,7 +17,9 @@ package org.hibernate.validator.internal.util.privilegedactions; import java.security.PrivilegedAction; -import javax.validation.ValidationException; + +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * @author Emmanuel Bernard @@ -26,6 +28,8 @@ */ public final class LoadClass implements PrivilegedAction> { + private static final Log log = LoggerFactory.make(); + private static final String HIBERNATE_VALIDATOR_CLASS_NAME = "org.hibernate.validator"; private final String className; @@ -68,11 +72,11 @@ private Class loadClassInValidatorNameSpace() { return contextClassLoader.loadClass( className ); } else { - throw new ValidationException( "Unable to load class: " + className ); + throw log.unableToLoadClass( className ); } } catch ( ClassNotFoundException e ) { - throw new ValidationException( "Unable to load class: " + className, e ); + throw log.unableToLoadClass( className, e ); } } @@ -93,7 +97,7 @@ private Class loadNonValidatorClass() { return Class.forName( className, true, caller.getClassLoader() ); } catch ( ClassNotFoundException e ) { - throw new ValidationException( "Unable to load class: " + className, e ); + throw log.unableToLoadClass( className, e ); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/NewInstance.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/NewInstance.java index 748507a53d..8640d35266 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/NewInstance.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/privilegedactions/NewInstance.java @@ -17,7 +17,9 @@ package org.hibernate.validator.internal.util.privilegedactions; import java.security.PrivilegedAction; -import javax.validation.ValidationException; + +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** * Execute instance creation as privileged action. @@ -26,6 +28,9 @@ * @author Hardy Ferentschik */ public final class NewInstance implements PrivilegedAction { + + private static final Log log = LoggerFactory.make(); + private final Class clazz; private final String message; @@ -43,13 +48,13 @@ public T run() { return clazz.newInstance(); } catch ( InstantiationException e ) { - throw new ValidationException( "Unable to instantiate " + message + ": " + clazz, e ); + throw log.unableToInstantiate( message, clazz, e ); } catch ( IllegalAccessException e ) { - throw new ValidationException( "Unable to instantiate " + clazz, e ); + throw log.unableToInstantiate( clazz, e ); } catch ( RuntimeException e ) { - throw new ValidationException( "Unable to instantiate " + clazz, e ); + throw log.unableToInstantiate( clazz, e ); } } } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/scriptengine/ScriptEvaluatorFactory.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/scriptengine/ScriptEvaluatorFactory.java index 7cf4edab98..378922646e 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/scriptengine/ScriptEvaluatorFactory.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/util/scriptengine/ScriptEvaluatorFactory.java @@ -24,6 +24,9 @@ import javax.script.ScriptEngineManager; import javax.script.ScriptException; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * Factory responsible for the creation of {@link ScriptEvaluator}s. This * class is thread-safe. @@ -33,6 +36,8 @@ */ public class ScriptEvaluatorFactory { + private static final Log log = LoggerFactory.make(); + /** * A reference with an instance of this factory. Allows the factory to be reused several times, but can be GC'ed if required. */ @@ -97,7 +102,7 @@ private ScriptEvaluator createNewScriptEvaluator(String languageName) throws Scr ScriptEngine engine = new ScriptEngineManager().getEngineByName( languageName ); if ( engine == null ) { - throw new ScriptException( "No JSR 223 script engine found for language \"" + languageName + "\"." ); + throw log.unableToFindScriptEngine( languageName ); } return new ScriptEvaluator( engine ); diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/xml/ValidationXmlParser.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/xml/ValidationXmlParser.java index 7219a6bf8c..822e54b4b9 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/xml/ValidationXmlParser.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/xml/ValidationXmlParser.java @@ -86,9 +86,7 @@ private void setConstraintFactoryFromXml(ValidationConfigType config, Validation log.usingConstraintFactory( constraintFactoryClass ); } catch ( ValidationException e ) { - throw new ValidationException( - "Unable to instantiate constraint factory class " + constraintFactoryClass + ".", e - ); + throw log.unableToInstantiateConstraintFactoryClass( constraintFactoryClass, e ); } } } @@ -112,7 +110,7 @@ private void setMappingStreamsFromXml(ValidationConfigType config, ValidationBoo InputStream in = getInputStreamForPath( mappingFileName ); if ( in == null ) { - throw new ValidationException( "Unable to open input stream for mapping file " + mappingFileName + "." ); + throw log.unableToOpenInputStreamForMappingFile( mappingFileName ); } xmlParameters.addMapping( in ); } @@ -130,19 +128,13 @@ private void setMessageInterpolatorFromXml(ValidationConfigType config, Validati log.usingMessageInterpolator( messageInterpolatorClass ); } catch ( ValidationException e ) { - throw new ValidationException( - "Unable to instantiate message interpolator class " + messageInterpolatorClass + ".", e - ); + throw log.unableToInstantiateMessageInterpolatorClass( messageInterpolatorClass, e ); } catch ( InstantiationException e ) { - throw new ValidationException( - "Unable to instantiate message interpolator class " + messageInterpolatorClass + ".", e - ); + throw log.unableToInstantiateMessageInterpolatorClass( messageInterpolatorClass, e ); } catch ( IllegalAccessException e ) { - throw new ValidationException( - "Unable to instantiate message interpolator class " + messageInterpolatorClass + ".", e - ); + throw log.unableToInstantiateMessageInterpolatorClass( messageInterpolatorClass, e ); } } } @@ -159,19 +151,13 @@ private void setTraversableResolverFromXml(ValidationConfigType config, Validati log.usingTraversableResolver( traversableResolverClass ); } catch ( ValidationException e ) { - throw new ValidationException( - "Unable to instantiate traversable resolver class " + traversableResolverClass + ".", e - ); + throw log.unableToInstantiateTraversableResolverClass( traversableResolverClass, e ); } catch ( InstantiationException e ) { - throw new ValidationException( - "Unable to instantiate traversable resolver class " + traversableResolverClass + ".", e - ); + throw log.unableToInstantiateTraversableResolverClass( traversableResolverClass, e ); } catch ( IllegalAccessException e ) { - throw new ValidationException( - "Unable to instantiate traversable resolver class " + traversableResolverClass + ".", e - ); + throw log.unableToInstantiateTraversableResolverClass( traversableResolverClass, e ); } } } @@ -189,9 +175,7 @@ private void setProviderClassFromXml(ValidationConfigType config, ValidationBoot log.usingValidationProvider( providerClassName ); } catch ( Exception e ) { - throw new ValidationException( - "Unable to instantiate validation provider class " + providerClassName + ".", e - ); + throw log.unableToInstantiateValidationProviderClass( providerClassName, e ); } } } @@ -217,7 +201,7 @@ private ValidationConfigType getValidationConfig() { validationConfig = root.getValue(); } catch ( JAXBException e ) { - throw new ValidationException( "Unable to parse " + VALIDATION_XML_FILE, e ); + throw log.unableToParseValidationXmlFile( VALIDATION_XML_FILE, e ); } finally { try { diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/internal/xml/XmlMappingParser.java b/hibernate-validator/src/main/java/org/hibernate/validator/internal/xml/XmlMappingParser.java index d27586d5cd..cdbc95bdf7 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/internal/xml/XmlMappingParser.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/internal/xml/XmlMappingParser.java @@ -32,7 +32,6 @@ import javax.validation.Constraint; import javax.validation.ConstraintValidator; import javax.validation.Payload; -import javax.validation.ValidationException; import javax.xml.bind.JAXBContext; import javax.xml.bind.JAXBElement; import javax.xml.bind.JAXBException; @@ -140,7 +139,7 @@ private void parseConstraintDefinitions(List constrain Class clazz = getClass( annotationClassName, defaultPackage ); if ( !clazz.isAnnotation() ) { - throw new ValidationException( annotationClassName + " is not an annotation" ); + throw log.isNotAnAnnotation( annotationClassName ); } Class annotationClass = (Class) clazz; @@ -158,7 +157,7 @@ private void parseConstraintDefinitions(List constrain if ( !ConstraintValidator.class.isAssignableFrom( validatorClass ) ) { - throw new ValidationException( validatorClass + " is not a constraint validator class" ); + throw log.isNotAConstraintValidatorClass( validatorClass ); } constraintValidatorClasses.add( validatorClass ); @@ -185,7 +184,7 @@ private void parseConstraintDefinitions(List constrain private void checkClassHasNotBeenProcessed(Set> processedClasses, Class beanClass) { if ( processedClasses.contains( beanClass ) ) { - throw new ValidationException( beanClass.getName() + " has already be configured in xml." ); + throw log.beanClassHasAlreadyBeConfiguredInXml( beanClass.getName() ); } } @@ -194,14 +193,14 @@ private void parseFieldLevelOverrides(List fields, Class beanClass for ( FieldType fieldType : fields ) { String fieldName = fieldType.getName(); if ( fieldNames.contains( fieldName ) ) { - throw new ValidationException( fieldName + " is defined twice in mapping xml for bean " + beanClass.getName() ); + throw log.isDefinedTwiceInMappingXmlForBean( fieldName, beanClass.getName() ); } else { fieldNames.add( fieldName ); } final boolean containsField = ReflectionHelper.containsDeclaredField( beanClass, fieldName ); if ( !containsField ) { - throw new ValidationException( beanClass.getName() + " does not contain the fieldType " + fieldName ); + throw log.beanDoesNotContainTheField( beanClass.getName(), fieldName ); } final Field field = ReflectionHelper.getDeclaredField( beanClass, fieldName ); @@ -231,14 +230,14 @@ private void parsePropertyLevelOverrides(List getters, Class bean for ( GetterType getterType : getters ) { String getterName = getterType.getName(); if ( getterNames.contains( getterName ) ) { - throw new ValidationException( getterName + " is defined twice in mapping xml for bean " + beanClass.getName() ); + throw log.isDefinedTwiceInMappingXmlForBean( getterName, beanClass.getName() ); } else { getterNames.add( getterName ); } boolean containsMethod = ReflectionHelper.containsMethodWithPropertyName( beanClass, getterName ); if ( !containsMethod ) { - throw new ValidationException( beanClass.getName() + " does not contain the property " + getterName ); + throw log.beanDoesNotContainTheProperty( beanClass.getName(), getterName ); } final Method method = ReflectionHelper.getMethodFromPropertyName( beanClass, getterName ); @@ -343,9 +342,7 @@ private MetaConstraint createMetaConstraint(Constra annotation = AnnotationFactory.create( annotationDescriptor ); } catch ( RuntimeException e ) { - throw new ValidationException( - "Unable to create annotation for configured constraint: " + e.getMessage(), e - ); + throw log.unableToCreateAnnotationForConfiguredConstraint( e.getMessage(), e ); } java.lang.annotation.ElementType type = java.lang.annotation.ElementType.TYPE; @@ -368,7 +365,7 @@ else if ( member instanceof Field ) { private Class getAnnotationParameterType(Class annotationClass, String name) { Method m = ReflectionHelper.getMethod( annotationClass, name ); if ( m == null ) { - throw new ValidationException( "Annotation of type " + annotationClass.getName() + " does not contain a parameter " + name + "." ); + throw log.annotationDoesNotContainAParameter( annotationClass.getName(), name ); } return m.getReturnType(); } @@ -379,7 +376,7 @@ private Object getElementValue(ElementType elementType, Class returnType) { boolean isArray = returnType.isArray(); if ( !isArray ) { if ( elementType.getContent().size() != 1 ) { - throw new ValidationException( "Attempt to specify an array where single value is expected." ); + throw log.attemptToSpecifyAnArrayWhereSingleValueIsExpected(); } return getSingleValue( elementType.getContent().get( 0 ), returnType ); } @@ -425,11 +422,11 @@ else if ( serializable instanceof JAXBElement && ( (JAXBElement) serializable returnValue = createAnnotation( annotationType, annotationClass ); } catch ( ClassCastException e ) { - throw new ValidationException( "Unexpected parameter value", e ); + throw log.unexpectedParameterValue( e ); } } else { - throw new ValidationException( "Unexpected parameter value" ); + throw log.unexpectedParameterValue(); } return returnValue; @@ -453,7 +450,7 @@ private Object convertStringToReturnType(Class returnType, String value) { returnValue = Byte.parseByte( value ); } catch ( NumberFormatException e ) { - throw new ValidationException( "Invalid byte format", e ); + throw log.invalidNumberFormat( "byte", e ); } } else if ( returnType.getName().equals( short.class.getName() ) ) { @@ -461,7 +458,7 @@ else if ( returnType.getName().equals( short.class.getName() ) ) { returnValue = Short.parseShort( value ); } catch ( NumberFormatException e ) { - throw new ValidationException( "Invalid short format", e ); + throw log.invalidNumberFormat( "short", e ); } } else if ( returnType.getName().equals( int.class.getName() ) ) { @@ -469,7 +466,7 @@ else if ( returnType.getName().equals( int.class.getName() ) ) { returnValue = Integer.parseInt( value ); } catch ( NumberFormatException e ) { - throw new ValidationException( "Invalid int format", e ); + throw log.invalidNumberFormat( "int", e ); } } else if ( returnType.getName().equals( long.class.getName() ) ) { @@ -477,7 +474,7 @@ else if ( returnType.getName().equals( long.class.getName() ) ) { returnValue = Long.parseLong( value ); } catch ( NumberFormatException e ) { - throw new ValidationException( "Invalid long format", e ); + throw log.invalidNumberFormat( "long", e ); } } else if ( returnType.getName().equals( float.class.getName() ) ) { @@ -485,7 +482,7 @@ else if ( returnType.getName().equals( float.class.getName() ) ) { returnValue = Float.parseFloat( value ); } catch ( NumberFormatException e ) { - throw new ValidationException( "Invalid float format", e ); + throw log.invalidNumberFormat( "float", e ); } } else if ( returnType.getName().equals( double.class.getName() ) ) { @@ -493,7 +490,7 @@ else if ( returnType.getName().equals( double.class.getName() ) ) { returnValue = Double.parseDouble( value ); } catch ( NumberFormatException e ) { - throw new ValidationException( "Invalid double format", e ); + throw log.invalidNumberFormat( "double", e ); } } else if ( returnType.getName().equals( boolean.class.getName() ) ) { @@ -501,7 +498,7 @@ else if ( returnType.getName().equals( boolean.class.getName() ) ) { } else if ( returnType.getName().equals( char.class.getName() ) ) { if ( value.length() != 1 ) { - throw new ValidationException( "Invalid char value: " + value ); + throw log.invalidCharValue( value ); } returnValue = value.charAt( 0 ); } @@ -518,9 +515,7 @@ else if ( returnType.getName().equals( Class.class.getName() ) ) { returnValue = Enum.valueOf( enumClass, value ); } catch ( ClassCastException e ) { - throw new ValidationException( - "Invalid return type: " + returnType + ". Should be a enumeration type.", e - ); + throw log.invalidReturnType( returnType, e ); } } return returnValue; @@ -528,7 +523,7 @@ else if ( returnType.getName().equals( Class.class.getName() ) ) { private void checkNameIsValid(String name) { if ( MESSAGE_PARAM.equals( name ) || GROUPS_PARAM.equals( name ) ) { - throw new ValidationException( MESSAGE_PARAM + ", " + GROUPS_PARAM + ", " + PAYLOAD_PARAM + " are reserved parameter names." ); + throw log.reservedParameterNames( MESSAGE_PARAM, GROUPS_PARAM, PAYLOAD_PARAM ); } } @@ -554,7 +549,7 @@ private Class[] getPayload(PayloadType payloadType, String de for ( String groupClass : payloadType.getValue() ) { Class payload = getClass( groupClass, defaultPackage ); if ( !Payload.class.isAssignableFrom( payload ) ) { - throw new ValidationException( "Specified payload class " + payload.getName() + " does not implement javax.validation.Payload" ); + throw log.wrongPayloadClass( payload.getName() ); } else { payloadList.add( (Class) payload ); @@ -590,7 +585,7 @@ private ConstraintMappingsType getValidationConfig(InputStream in) { constraintMappings = root.getValue(); } catch ( JAXBException e ) { - throw new ValidationException( "Error parsing mapping file.", e ); + throw log.errorParsingMappingFile( e ); } return constraintMappings; } diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/messageinterpolation/ValueFormatterMessageInterpolator.java b/hibernate-validator/src/main/java/org/hibernate/validator/messageinterpolation/ValueFormatterMessageInterpolator.java index caa45fe83f..45402307d0 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/messageinterpolation/ValueFormatterMessageInterpolator.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/messageinterpolation/ValueFormatterMessageInterpolator.java @@ -22,7 +22,9 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.validation.MessageInterpolator; -import javax.validation.ValidationException; + +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; /** @@ -36,6 +38,9 @@ * @author Hardy Ferentschik */ public class ValueFormatterMessageInterpolator implements MessageInterpolator { + + private static final Log log = LoggerFactory.make(); + public static final String VALIDATED_VALUE_KEYWORD = "validatedValue"; public static final String VALIDATED_VALUE_FORMAT_SEPARATOR = ":"; @@ -134,7 +139,7 @@ else if ( current == '}' ) { */ private boolean isEscaped(String enclosingString, int charIndex) { if ( charIndex < 0 || charIndex > enclosingString.length() ) { - throw new IndexOutOfBoundsException( "The given index must be between 0 and enclosingString.length() - 1" ); + throw log.invalidIndex("0", "enclosingString.length() - 1"); } return charIndex > 0 && enclosingString.charAt( charIndex - 1 ) == '\\'; } @@ -158,13 +163,13 @@ private String interpolateValidatedValue(String expression, Object validatedValu else { String format = expression.substring( separatorIndex + 1, expression.length() - 1 ); if ( format.length() == 0 ) { - throw new ValidationException( "Missing format string in template: " + expression ); + throw log.missingFormatStringInTemplate( expression ); } try { interpolatedValue = String.format( locale, format, validatedValue ); } catch ( IllegalFormatException e ) { - throw new ValidationException( "Invalid format: " + e.getMessage(), e ); + throw log.invalidFormat( e.getMessage(), e ); } } return interpolatedValue; diff --git a/hibernate-validator/src/main/java/org/hibernate/validator/resourceloading/AggregateResourceBundleLocator.java b/hibernate-validator/src/main/java/org/hibernate/validator/resourceloading/AggregateResourceBundleLocator.java index 9da18c23ff..70dc97ad29 100644 --- a/hibernate-validator/src/main/java/org/hibernate/validator/resourceloading/AggregateResourceBundleLocator.java +++ b/hibernate-validator/src/main/java/org/hibernate/validator/resourceloading/AggregateResourceBundleLocator.java @@ -26,6 +26,10 @@ import java.util.Map; import java.util.ResourceBundle; +import org.hibernate.validator.internal.util.Contracts; +import org.hibernate.validator.internal.util.logging.Log; +import org.hibernate.validator.internal.util.logging.LoggerFactory; + /** * A {@link ResourceBundleLocator} implementation that provides access * to multiple source {@link ResourceBundle}s by merging them into one @@ -35,6 +39,8 @@ */ public class AggregateResourceBundleLocator extends DelegatingResourceBundleLocator { + private static final Log log = LoggerFactory.make(); + private final List bundleNames; /** @@ -65,9 +71,7 @@ public AggregateResourceBundleLocator(List bundleNames) { public AggregateResourceBundleLocator(List bundleNames, ResourceBundleLocator delegate) { super( delegate ); - if ( bundleNames == null ) { - throw new IllegalArgumentException( "bundleNames must not be null." ); - } + Contracts.assertNotNull( bundleNames, log.mustNotBeNull( "bundleNames" ) ); List tmpBundleNames = new ArrayList(); tmpBundleNames.addAll( bundleNames );