Java DecimalMax類代碼示例

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
@Override
public Object process(AnnotationInfo ctx, Object value) throws Exception {
    if (!ctx.isAnnotationPresent(DecimalMin.class)
            && !ctx.isAnnotationPresent(DecimalMax.class)) {
        return value;
    }
    String minValue = "1";
    if (ctx.isAnnotationPresent(DecimalMin.class)) {
        minValue = ctx.getAnnotation(DecimalMin.class).value();
    }
    String maxValue = "50";
    if (ctx.isAnnotationPresent(DecimalMax.class)) {
        maxValue = ctx.getAnnotation(DecimalMax.class).value();
    }
    return range(minValue, maxValue, value.getClass());
}
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
@Override
public void validate(DecimalMax decimalMaxAnnotation, String name, ValidationContext validationCtx, Errors errors) {
    Object value = validationCtx.value(name);

    if (value == null)
        return;

    if (!(value instanceof BigDecimal))
        errors.add(name, "validation.error.notDecimal", value);

    if (!validateMax(BigDecimal.valueOf(Double.valueOf(decimalMaxAnnotation.value())), value)) {
        errors.add(name, "validation.error.maxDecimal", value, decimalMaxAnnotation.value());
    }
}
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
@PostConstruct
public void init() {
	validationAnnotations = new HashSet<>();
	validationAnnotations.addAll(Arrays.asList(NotNull.class, Size.class,
			Pattern.class, DecimalMin.class, DecimalMax.class, Min.class,
			Max.class));

}
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
@Test
  public void checkJSR303() {
  	PojoGenerationConfig jsr303Config = new PojoGenerationConfig().withPackage("com.gen.foo", "").withJSR303Annotations(true);
      assertThat(ramlRoot, is(notNullValue()));
      RamlResource validations = ramlRoot.getResource("/validations");
      
      RamlDataType validationsGetType = validations.getAction(RamlActionType.GET).getResponses().get("200").getBody().get("application/json").getType();
      assertThat(validationsGetType, is(notNullValue()));        
      ApiBodyMetadata validationsGetRequest = RamlTypeHelper.mapTypeToPojo(jsr303Config, jCodeModel, ramlRoot, validationsGetType.getType());
      assertThat(validationsGetRequest, is(notNullValue()));        
      assertThat(validationsGetRequest.getName(), is("Validation"));      
      assertThat(validationsGetRequest.isArray(), is(false)); 
      
JDefinedClass validation = (JDefinedClass) CodeModelHelper.findFirstClassBySimpleName(jCodeModel, "Validation");

checkIfFieldContainsAnnotation(true, validation, NotNull.class, "lastname", "pattern", "length", "id", "anEnum", "anotherEnum");
checkIfFieldContainsAnnotation(false, validation, NotNull.class, "firstname", "minLength");
checkIfFieldContainsAnnotation(true, validation, Size.class, "length", "minLength");
checkIfFieldContainsAnnotation(true, validation, Pattern.class, "pattern");

checkIfAnnotationHasParameter(validation, Size.class, "length","min");
checkIfAnnotationHasParameter(validation, Size.class, "length","max");
checkIfAnnotationHasParameter(validation, Size.class, "minLength","min");
checkIfAnnotationHasParameter(validation, Pattern.class, "pattern","regexp");

checkIfAnnotationHasParameter(validation, DecimalMin.class, "id","value");
checkIfAnnotationHasParameter(validation, DecimalMax.class, "id","value");

JFieldVar anEnum = getField(validation, "anEnum");
assertThat(anEnum.type().fullName(), is("com.gen.foo.AnEnum")); 

JFieldVar anotherEnum = getField(validation, "anotherEnum");
assertThat(anotherEnum.type().fullName(), is("com.gen.foo.EnumChecks"));

JDefinedClass enumChecks = (JDefinedClass) CodeModelHelper.findFirstClassBySimpleName(jCodeModel, "EnumChecks");
String elementAsString = CodeModelHelper.getElementAsString(enumChecks);
assertThat(elementAsString, not(containsString("(\"value_with_underscore\", \"value_with_underscore\")"))); 
assertThat(elementAsString, containsString("FEE(\"fee\")")); 
assertThat(elementAsString, containsString("TESTFEE(\"testfee\")")); 
  }
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
private static void mapBeanValidationParameter(Annotation annotation, InstanceDescriptor element) {
  	SimpleTypeDescriptor typeDescriptor = (SimpleTypeDescriptor) element.getLocalType(false);
if (annotation instanceof AssertFalse)
  		typeDescriptor.setTrueQuota(0.);
  	else if (annotation instanceof AssertTrue)
  		typeDescriptor.setTrueQuota(1.);
  	else if (annotation instanceof DecimalMax)
  		typeDescriptor.setMax(String.valueOf(DescriptorUtil.convertType(((DecimalMax) annotation).value(), typeDescriptor)));
  	else if (annotation instanceof DecimalMin)
  		typeDescriptor.setMin(String.valueOf(DescriptorUtil.convertType(((DecimalMin) annotation).value(), typeDescriptor)));
  	else if (annotation instanceof Digits) {
  		Digits digits = (Digits) annotation;
	typeDescriptor.setGranularity(String.valueOf(Math.pow(10, - digits.fraction())));
  	} else if (annotation instanceof Future)
       typeDescriptor.setMin(new SimpleDateFormat("yyyy-MM-dd").format(TimeUtil.tomorrow()));
      else if (annotation instanceof Max)
	typeDescriptor.setMax(String.valueOf(((Max) annotation).value()));
      else if (annotation instanceof Min)
  		typeDescriptor.setMin(String.valueOf(((Min) annotation).value()));
  	else if (annotation instanceof NotNull) {
  		element.setNullable(false);
  		element.setNullQuota(0.);
  	} else if (annotation instanceof Null) {
  		element.setNullable(true);
  		element.setNullQuota(1.);
  	} else if (annotation instanceof Past)
       typeDescriptor.setMax(new SimpleDateFormat("yyyy-MM-dd").format(TimeUtil.yesterday()));
      else if (annotation instanceof Pattern)
  		typeDescriptor.setPattern(String.valueOf(((Pattern) annotation).regexp()));
  	else if (annotation instanceof Size) {
  		Size size = (Size) annotation;
  		typeDescriptor.setMinLength(size.min());
  		typeDescriptor.setMaxLength(size.max());
  	}
  }
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
@Override
public boolean incudeInValidation(DecimalMax decimalMaxAnnotation, RequestHandler requestHandler, ValidationContext validationCtx) {
    return true;
}
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
@DecimalMin("0.0")
@DecimalMax("1.0")
public double getFailureRatioThreshold()
{
    return failureRatioThreshold;
}
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
@Override
public void initialize(final DecimalMax maxValue) {
    this.maxValue = new BigDecimal(maxValue.value() );
    this.inclusive = maxValue.inclusive();
}
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
@Test
public void shouldAssignFieldValidation() throws Exception {
    TypeValidationDto intMinValue = new TypeValidationDto("mds.field.validation.minValue", Integer.class.getName());
    TypeValidationDto intMaxValue = new TypeValidationDto("mds.field.validation.maxValue", Integer.class.getName());
    TypeValidationDto intMustBeInSet = new TypeValidationDto("mds.field.validation.mustBeInSet", String.class.getName());
    TypeValidationDto intCannotBeInSet = new TypeValidationDto("mds.field.validation.cannotBeInSet", String.class.getName());

    TypeValidationDto decMinValue = new TypeValidationDto("mds.field.validation.minValue", Double.class.getName());
    TypeValidationDto decMaxValue = new TypeValidationDto("mds.field.validation.maxValue", Double.class.getName());
    TypeValidationDto decMustBeInSet = new TypeValidationDto("mds.field.validation.mustBeInSet", String.class.getName());
    TypeValidationDto decCannotBeInSet = new TypeValidationDto("mds.field.validation.cannotBeInSet", String.class.getName());

    TypeValidationDto regex = new TypeValidationDto("mds.field.validation.regex", String.class.getName());
    TypeValidationDto minLength = new TypeValidationDto("mds.field.validation.minLength", Integer.class.getName());
    TypeValidationDto maxLength = new TypeValidationDto("mds.field.validation.maxLength", Integer.class.getName());

    doReturn(singletonList(intMinValue)).when(schemaHolder).findValidations(Integer.class.getName(), DecimalMin.class);
    doReturn(singletonList(intMaxValue)).when(schemaHolder).findValidations(Integer.class.getName(), DecimalMax.class);
    doReturn(singletonList(intMustBeInSet)).when(schemaHolder).findValidations(Integer.class.getName(), InSet.class);
    doReturn(singletonList(intCannotBeInSet)).when(schemaHolder).findValidations(Integer.class.getName(), NotInSet.class);
    doReturn(singletonList(intMinValue)).when(schemaHolder).findValidations(Integer.class.getName(), Min.class);
    doReturn(singletonList(intMaxValue)).when(schemaHolder).findValidations(Integer.class.getName(), Max.class);

    doReturn(singletonList(decMinValue)).when(schemaHolder).findValidations(Double.class.getName(), DecimalMin.class);
    doReturn(singletonList(decMaxValue)).when(schemaHolder).findValidations(Double.class.getName(), DecimalMax.class);
    doReturn(singletonList(decMustBeInSet)).when(schemaHolder).findValidations(Double.class.getName(), InSet.class);
    doReturn(singletonList(decCannotBeInSet)).when(schemaHolder).findValidations(Double.class.getName(), NotInSet.class);
    doReturn(singletonList(decMinValue)).when(schemaHolder).findValidations(Double.class.getName(), Min.class);
    doReturn(singletonList(decMaxValue)).when(schemaHolder).findValidations(Double.class.getName(), Max.class);

    doReturn(singletonList(regex)).when(schemaHolder).findValidations(String.class.getName(), Pattern.class);
    doReturn(asList(minLength, maxLength)).when(schemaHolder).findValidations(String.class.getName(), Size.class);
    doReturn(singletonList(minLength)).when(schemaHolder).findValidations(String.class.getName(), DecimalMin.class);
    doReturn(singletonList(maxLength)).when(schemaHolder).findValidations(String.class.getName(), DecimalMax.class);

    processor.execute(bundle, schemaHolder);
    Collection<FieldDto> fields = processor.getElements();

    FieldDto pi = findFieldWithName(fields, "pi");
    assertCriterion(pi, "mds.field.validation.minValue", "3");
    assertCriterion(pi, "mds.field.validation.maxValue", "4");
    assertCriterion(pi, "mds.field.validation.mustBeInSet", "3,3.14,4");
    assertCriterion(pi, "mds.field.validation.cannotBeInSet", "1,2,5");

    FieldDto epsilon = findFieldWithName(fields, "epsilon");
    assertCriterion(epsilon, "mds.field.validation.minValue", "0.0");
    assertCriterion(epsilon, "mds.field.validation.maxValue", "1.0");
    assertCriterion(epsilon, "mds.field.validation.mustBeInSet", "1,0.75,0.5,0.25,0");
    assertCriterion(epsilon, "mds.field.validation.cannotBeInSet", "-1,2,3");

    FieldDto random = findFieldWithName(fields, "random");
    assertCriterion(random, "mds.field.validation.minValue", "0");
    assertCriterion(random, "mds.field.validation.maxValue", "10");

    FieldDto gaussian = findFieldWithName(fields, "gaussian");
    assertCriterion(gaussian, "mds.field.validation.minValue", "0.0");
    assertCriterion(gaussian, "mds.field.validation.maxValue", "1.0");

    FieldDto poem = findFieldWithName(fields, "poem");
    assertCriterion(poem, "mds.field.validation.regex", "[A-Z][a-z]{9}");
    assertCriterion(poem, "mds.field.validation.minLength", "10");
    assertCriterion(poem, "mds.field.validation.maxLength", "20");

    FieldDto article = findFieldWithName(fields, "article");
    assertCriterion(article, "mds.field.validation.minLength", "100");
    assertCriterion(article, "mds.field.validation.maxLength", "500");
}
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
@Override
public Randomizer<?> getRandomizer(Field field) {
    Class<?> fieldType = field.getType();
    if (ReflectionUtils.isAnnotationPresent(field, DecimalMin.class) || ReflectionUtils
            .isAnnotationPresent(field, DecimalMax.class)) {
        DecimalMax decimalMaxAnnotation = ReflectionUtils
                .getAnnotation(field, DecimalMax.class);
        DecimalMin decimalMinAnnotation = ReflectionUtils
                .getAnnotation(field, DecimalMin.class);

        BigDecimal maxValue = null;
        BigDecimal minValue = null;

        if (decimalMaxAnnotation != null) {
            maxValue = new BigDecimal(decimalMaxAnnotation.value());
        }

        if (decimalMinAnnotation != null) {
            minValue = new BigDecimal(decimalMinAnnotation.value());
        }

        if (fieldType.equals(Byte.TYPE) || fieldType.equals(Byte.class)) {
            return new ByteRangeRandomizer(
                    minValue == null ? null : minValue.byteValue(),
                    maxValue == null ? null : maxValue.byteValue(),
                    random.nextLong()
            );
        }
        if (fieldType.equals(Short.TYPE) || fieldType.equals(Short.class)) {
            return new ShortRangeRandomizer(
                    minValue == null ? null : minValue.shortValue(),
                    maxValue == null ? null : maxValue.shortValue(),
                    random.nextLong()
            );
        }
        if (fieldType.equals(Integer.TYPE) || fieldType.equals(Integer.class)) {
            return new IntegerRangeRandomizer(
                    minValue == null ? null : minValue.intValue(),
                    maxValue == null ? null : maxValue.intValue(),
                    random.nextLong()
            );
        }
        if (fieldType.equals(Long.TYPE) || fieldType.equals(Long.class)) {
            return new LongRangeRandomizer(
                    minValue == null ? null : minValue.longValue(),
                    maxValue == null ? null : maxValue.longValue(),
                    random.nextLong()
            );
        }
        if (fieldType.equals(BigInteger.class)) {
            return new BigIntegerRangeRandomizer(
                    minValue == null ? null : minValue.intValue(),
                    maxValue == null ? null : maxValue.intValue(),
                    random.nextLong()
            );
        }
        if (fieldType.equals(BigDecimal.class)) {
            return new BigDecimalRangeRandomizer(
                    minValue == null ? null : minValue.longValue(),
                    maxValue == null ? null : maxValue.longValue(),
                    random.nextLong()
            );
        }
        if (fieldType.equals(String.class)) {
            BigDecimalRangeRandomizer delegate = new BigDecimalRangeRandomizer(
                    minValue == null ? null : minValue.longValue(),
                    maxValue == null ? null : maxValue.longValue(),
                    random.nextLong()
            );
            return new StringDelegatingRandomizer(delegate);
        }
    }
    return null;
}
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
@DecimalMax(value="20", groups=Group3.class)
Integer getAge() {
    return age;
}
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
/**
 * The longitude of the point, in decimal degrees (WGS84 datum).
 *
 * <p>
 * The value cannot be null, must be superior or equal to -180.0 and
 * inferior to 180.0 degrees.
 *
 * @return the longitude of the point
 */
@NotNull(message = "{Model.Coordinates.Longitude.NotNull}")
@DecimalMax(value = "180", inclusive = false,
        message = "{Model.Coordinates.Longitude.MaxValue}")
@DecimalMin(value = "-180",
        message = "{Model.Coordinates.Longitude.MinValue}")
Double getLongitude();
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
/**
 * The difference in elevation (in meters) between this point and the
 * previous point in the trail.
 *
 * @return the difference in elevation (in meters) between this point and
 * the previous point in the trail
 */
@DecimalMin(value = "-9450", message = "{Model.Waypoint.EleDiff.Positive}")
@DecimalMax(value = "9450", message = "{Model.Waypoint.EleDiff.Max}")
Double getElevationDifference();
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
/**
 * The inclination between this waypoint and the previous one, as an angle
 * of inclination to the horizontal.
 *
 * @return the inclination between this waypoint and the previous one
 */
@DecimalMin(value = "-90", message = "{Model.Waypoint.Grade.MinValue}")
@DecimalMax(value = "90.0", message = "{Model.Waypoint.Grade.MaxValue}")
Double getGrade();
 

import javax.validation.constraints.DecimalMax; //導入依賴的package包/類
/**
 * The latitude of the point, in decimal degrees (WGS84 datum).
 *
 * <p>
 * The latitude of the point, in decimal degrees. The value cannot be null
 * and must be between or equal to -90.0 and 90.0 degrees.
 *
 * @return the latitude of the point
 */
@NotNull(message = "{Model.Coordinates.Latitude.NotNull}")
@DecimalMax(value = "90", message = "{Model.Coordinates.Latitude.MaxValue}")
@DecimalMin(value = "-90",
        message = "{Model.Coordinates.Latitude.MinValue}")
Double getLatitude();