Java DecimalMin类代码示例

import javax.validation.constraints.DecimalMin; //导入依赖的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.DecimalMin; //导入依赖的package包/类
@Override
public void validate(DecimalMin decimalMinAnnotation, String name, ValidationContext validationCtx, Errors errors) {
    Object value = validationCtx.value(name);

    if (value == null)
        return;

    if (!(value instanceof BigDecimal))
        errors.add(name, decimalMinAnnotation.message(), value);

    if (!validateMin(BigDecimal.valueOf(Double.valueOf(decimalMinAnnotation.value())), value)) {
        errors.add(name, decimalMinAnnotation.message(), value, decimalMinAnnotation.value());
    }
}
 

import javax.validation.constraints.DecimalMin; //导入依赖的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.DecimalMin; //导入依赖的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.DecimalMin; //导入依赖的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.DecimalMin; //导入依赖的package包/类
@Column(name = "rating", columnDefinition="decimal(2,1) default 0.0")
@DecimalMin("0.1")
public float getRating() {
    return rating;
}
 

import javax.validation.constraints.DecimalMin; //导入依赖的package包/类
@Column(name = "price", columnDefinition="decimal(5,2)")
@DecimalMin("0.01")
public Float getPrice() {
    return price;
}
 

import javax.validation.constraints.DecimalMin; //导入依赖的package包/类
@NotNull
@DecimalMin("0.0")
@Column(name = "valor_frete", nullable = false, precision = 10, scale = 2)
public BigDecimal getValorFrete() {
	return valorFrete;
}
 

import javax.validation.constraints.DecimalMin; //导入依赖的package包/类
@NotNull
@DecimalMin("0.0")
@Column(name = "valor_desconto", nullable = false, precision = 10, scale = 2)
public BigDecimal getValorDesconto() {
	return valorDesconto;
}
 

import javax.validation.constraints.DecimalMin; //导入依赖的package包/类
@NotNull
@DecimalMin("0.0")
@Column(name = "valor_total", nullable = false, precision = 10, scale = 2)
public BigDecimal getValorTotal() {
	return valorTotal;
}
 

import javax.validation.constraints.DecimalMin; //导入依赖的package包/类
@Override
public boolean incudeInValidation(DecimalMin decimalMinAnnotation, RequestHandler requestHandler, ValidationContext validationCtx) {
    return true;
}
 

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

import javax.validation.constraints.DecimalMin; //导入依赖的package包/类
@Override
public void initialize(DecimalMin minValue) {
    this.minValue = new BigDecimal(minValue.value() );
    this.inclusive = minValue.inclusive();
}
 

import javax.validation.constraints.DecimalMin; //导入依赖的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.DecimalMin; //导入依赖的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;
}