En el ámbito del procesamiento de datos, la funcionalidad de importar archivos de Excel es una necesidad fundamental para la mayoría de los sistemas empresariales. Sin embargo, detrás del simple acto de "seleccionar archivo - hacer clic en importar", se esconden innumerables desafíos de validación de datos que pueden ser problemáticos para los desarrolladores. Esto es especialmente cierto cuando los requisitos de negocio exigen que ciertos campos deban cumplir con valores de enumeración predefinidos; una simple negligencia puede llevar a la contaminación de lotes enteros de datos. Este artículo comparte una solución probada en batalla que abarca desde el diseño de la validación hasta el manejo de errores, guiándolo paso a paso en la construcción de un sistema de importación de Excel robusto.

1. Estrategia Central para la Validación de Enumeraciones

La esencia de la validación de enumeraciones radica en establecer una relación de mapeo entre los datos y las reglas. Los enfoques tradicionales a menudo codifican la lógica de validación directamente en los métodos de negocio, lo que resulta en tres probelmas típicos:

1. Acoplamiento de las Reglas de Validación con el Código de Negocio: Cada cambio en la enumeración requiere modificar la lógica central.
2. Mensajes de Error Poco Amigables: El frontend solo recibe información vaga como "datos inválidos".
3. Baja Reutilización: Lógicas de validación idénticas se implementan repetidamente en diferentes interfaces.

Adoptamos una arquitectura de anotaciones + validación por reflexión para resolver estos problemas:

// Ejemplo de definición de anotación para validación de enumeraciones
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ExcelEnumValidation {
   Class extends Enum>> enumValues(); // Tipo de enumeración asociado
   boolean required() default true;     // Indica si el campo es obligatorio
   String errorMessage() default "Valor de enumeración no válido"; // Mensaje de error personalizado
}

Este diseño ofrece tres ventajas principales:

• Configuración Declarativa: Las anotaciones a nivel de campo hacen que las reglas de validación sean claras de un vistazo.
• Lógica de Validación Desacoplada: El flujo de validación se gestiona centralmente a través de un procesador unificado.
• Mensajes de Error Dinámicos: Admite la definición de mensajes de error amigables para el negocio directamente en la anotación.

2. Implementación Completa de la Clase de Utilidad de Validación

Basándonos en las anotaciones anteriores, necesitamos construir una clase de utilidad que pueda identificar y ejecutar automáticamente las validaciones. Aquí están los pasos clave de implementación:

2.1 Lógica Central del Procesador de Anotaciones

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class ExcelDataProcessor {

   private static final Validator jsr303Validator =
       Validation.buildDefaultValidatorFactory().getValidator();

   public static <T> void validateEntity(T entity) throws ExcelValidationException {
       // Validación básica JSR303
       Set<ConstraintViolation<T>> violations = jsr303Validator.validate(entity);
       if (!violations.isEmpty()) {
           throw new ExcelValidationException(
               violations.stream()
                   .map(v -> v.getPropertyPath() + ": " + v.getMessage())
                   .collect(Collectors.joining("; "))
           );
       }

       // Validación específica de enumeración
       List<String> enumErrors = new ArrayList<>();
       Field[] fields = entity.getClass().getDeclaredFields();

       for (Field field : fields) {
           ExcelEnumValidation enumAnnotation = field.getAnnotation(ExcelEnumValidation.class);
           if (enumAnnotation != null) {
               processEnumField(entity, field, enumAnnotation, enumErrors);
           }
       }

       if (!enumErrors.isEmpty()) {
           throw new ExcelValidationException(String.join("; ", enumErrors));
       }
   }

   private static <T> void processEnumField(T entity, Field field, ExcelEnumValidation annotation, List<String> errors) {
       field.setAccessible(true);
       try {
           Object value = field.get(entity);
           Class<? extends Enum<?>> enumClass = annotation.enumValues();
           boolean isRequired = annotation.required();
           String errorMessage = annotation.errorMessage();

           if (value == null || value.toString().isEmpty()) {
               if (isRequired) {
                   errors.add(field.getName() + ": " + errorMessage + " (campo obligatorio)");
               }
               return; // Saltar si es nulo y no requerido
           }

           boolean found = false;
           for (Enum<?> enumConstant : enumClass.getEnumConstants()) {
               // Compara el valor del campo con el nombre de la constante de enumeración
               // Se puede personalizar para comparar con otro atributo del enum si es necesario
               if (enumConstant.name().equalsIgnoreCase(value.toString())) {
                   found = true;
                   break;
               }
           }

           if (!found) {
               errors.add(field.getName() + ": '" + value + "' " + errorMessage);
           }

       } catch (IllegalAccessException e) {
           errors.add(field.getName() + ": Error de acceso al campo - " + e.getMessage());
       }
   }

   // Clase de excepción personalizada
   public static class ExcelValidationException extends Exception {
       public ExcelValidationException(String message) {
           super(message);
       }
   }
}

2.2 Ejemplo de Uso con una Clase de Datos de Ejemplo

Supongamos que tenemos una clase ProductRecord que representa una fila de datos importados y queremos validar el campo status.

public class ProductRecord {

   private String productName;

   @ExcelEnumValidation(enumValues = ProductStatus.class, required = true, errorMessage = "Estado del producto inválido")
   private String status;

   private double price;

   // Getters y Setters
   public String getProductName() { return productName; }
   public void setProductName(String productName) { this.productName = productName; }
   public String getStatus() { return status; }
   public void setStatus(String status) { this.status = status; }
   public double getPrice() { return price; }
   public void setPrice(double price) { this.price = price; }

   // Constructor, etc.
}

public enum ProductStatus {
   ACTIVE, INACTIVE, PENDING
}

Al importar datos, se invocaría ExcelDataProcessor.validateEntity(productRecordInstance);. Si el valor del campo status no coincide con ACTIVE, INACTIVE o PENDING, se lanzará una ExcelValidationException.