Validación de Java String usando valores de enumeración y anotación

Nuestros mejores desarrolladores han agotado sus reservas de café, por su búsqueda noche y día por la resolución, hasta que Liliana halló la respuesta en Beanstalk por lo tanto ahora la compartimos contigo.

Solución:

Así que aquí está el código que usa la validación de Spring y funciona muy bien para mí. El código completo se proporciona a continuación.

---

@EnumValidator definición de anotación:

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.ReportAsSingleViolation;
import javax.validation.constraints.NotNull;

@Documented
@Constraint(validatedBy = EnumValidatorImpl.class)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@NotNull(message = "Value cannot be null")
@ReportAsSingleViolation
public @interface EnumValidator 

  Class> enumClazz();

  String message() default "Value is not valid";

  Class[] groups() default ;

  Class[] payload() default ;

Implementación de la clase anterior:

import java.util.ArrayList;
import java.util.List;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class EnumValidatorImpl implements ConstraintValidator 

    List valueList = null;

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) 
        return valueList.contains(value.toUpperCase());
    

    @Override
    public void initialize(EnumValidator constraintAnnotation) 
        valueList = new ArrayList();
        Class> enumClass = constraintAnnotation.enumClazz();

        @SuppressWarnings("rawtypes")
        Enum[] enumValArr = enumClass.getEnumConstants();

        for (@SuppressWarnings("rawtypes") Enum enumVal : enumValArr) 
            valueList.add(enumVal.toString().toUpperCase());
        
    

uso de lo anterior anotación es muy simple

 @JsonProperty("lead_id")
 @EnumValidator(
     enumClazz = DefaultEnum.class,
     message = "This error is coming from the enum class",
     groups = Group1.class
 )
 private String leadId;

Esto es lo que hice.

Anotación

public @interface ValidateString 

    String[] acceptedValues();

    String message() default "uk.dds.ideskos.validator.ValidateString.message";

    Class[] groups() default  ;

    Class[] payload() default  ; 

Clase de validación

public class StringValidator implements ConstraintValidator

    private List valueList;

    @Override
    public void initialize(ValidateString constraintAnnotation) 
        valueList = new ArrayList();
        for(String val : constraintAnnotation.acceptedValues()) 
            valueList.add(val.toUpperCase());
        
    

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) 
        return valueList.contains(value.toUpperCase());
    

Y lo usé como

@ValidateString(acceptedValues="Integer", "String", message="Invalid dataType")
String dataType;

Long maxValue;
Long minValue;

Ahora necesito descubrir cómo implementar la verificación condicional, es decir. si String entonces maxValue y minValue deberían ser null o Cero..

¿Algunas ideas?

Deshazte de la representación de String y haz una enumeración real.

public enum DataType 
   STRING,
   BOOLEAN,
   INTEGER;

De esa manera evitas tener que hacer string comparación de la anterior String dataType variable para determinar si está en la enumeración. Aparte, también hace que sea imposible asignar un valor no válido a la variable miembro dataType y dado que se garantiza que las enumeraciones son singletons dentro del cargador de clases, también ahorra espacio en la memoria.

Vale la pena el esfuerzo de cambiar su código para usar enumeraciones. Sin embargo, suponiendo que no pueda, al menos puede cambiar la anotación para usar enumeraciones.

@ValidateString(DataType.STRING) String dataType;

y de esa manera tu ValidateString la anotación al menos se beneficia de las enumeraciones, incluso si el resto del código no lo hace.

Ahora, en el caso extremadamente raro de que no pueda usar una enumeración en absoluto, puede configurar static enteros públicos, que mapean cada valor aceptado.

public class DataType 
  public static final int STRING = 1;
  public static final int BOOLEAN = 2;
  ...

Sin embargo, si usa una cadena para el parámetro de anotación, no tenemos un sistema de verificación de tipo que se extienda al tipo para especificar que solo se permiten valores particulares. En otras palabras, Java carece de la capacidad de hacer algo como esto:

public int oddInt; 

que arrojaría un error si intentara asignar

 oddInt = 4;

¿Porque es esto importante? Porque si no se aplica a Java regular, entonces no se puede aplicar a la enumeración que se implementa en las clases de Java regulares.

Te mostramos las comentarios y valoraciones de los usuarios

Si te ha sido útil nuestro artículo, sería de mucha ayuda si lo compartieras con más seniors así contrubuyes a dar difusión a nuestro contenido.

---

---

Utiliza Nuestro Buscador