Validar formato de data utilizando Apache POI

Programação
,
#1

Pessoal boa noite, primeiramente comecei a estudar aplicações web em java recentemente e estou mexendo com poi para leitura de células em Excel, e gostaria de saber existe alguma forma de validação de campo de data que somente utilize esse estilo de formato “dd/MM/yyyy” na célula, utilizando o apache poi?

Criei um if que ele está permitindo qualquer de estilo de célula de data ser validado, por exemplo se o estilo for personalizado dd/MMM, ele permite esse estilo ser validado.

if(DateUtil.isCellDateFormatted(cell))
   {
       cell.getDateCellValue();
   }

Eu queria que só esse estilo de formato na célula “dd/MM/yyyy” , fosse válido.

Utilizei esse cara para quando baixar o arquivo ter um campo data com estilo formatado.

styleDateFormat.setDataFormat(HSSFDataFormat.getBuiltinFormat("dd/MM/yyyy"));

#2

Se DateUtil.isCellDateFormatted(cell) for verdadeiro, não importa o formato. Converte o valor numérico do Excel pra Date do Java, e a partir daí converte Date pra qualquer formato string que precisar apresentar.

1 curtida
#3

Qual a ideia estou tentando fazer com que o meu campo data só valide o seu campo se o estilo da célula estiver preenchido com o formato dd/MM/yyyy.

fiz algumas adaptações aqui:

private Campo extrairData(Row linhaExcel) {
         // valida linhas do Excel, colunas da planilha e nome da coluna
        Cell cell = PoiUtils.extractCell(linhaExcel, colunasDaPlanilha, DATE);

        if (cell == null){
             return CampoData.nulo();
       }
        else  if (cell.getCellTypeEnum() == CellType.NUMERIC && DateUtil.isCellDateFormatted(cell)) {
            return new CampoData(dp, cell.getDateCellValue());
        }

        return new CampoData(dp, cell.getStringCellValue());
    }

Representa meus campos de data:

public class CampoData implements Campo<Date> {
    
    private static final Pattern PADRAO_DATA_D_M_YYYY = Pattern.compile("^(0?[1-9]|1[0-9]|2[0-9]|3[01])/(1[0-2]|0?[1-9])/[0-9]{4}");
    private static final Pattern PADRAO_DATA_M_D_YY = Pattern.compile("^(1[0-2]|0?[1-9])/(0?[1-9]|1[0-9]|2[0-9]|3[01])/[0-9]{2}");

    private static final Campo<Date> CAMPO_NULO = new CampoData();

    private Date data;
    private String valorOriginal;
    private FormatoDatasPlanilha dp;

    private CampoData() {}
    
    /**
     * Valida o formato do campo data 
     * @param datasPlanilha - Formatos de datas prontos.
     * @param data
     */
    CampoData(FormatoDatasPlanilha dp, Date data) {
        this.dp = Objects.requireNonNull(dp, "O campo 'datasPlanilha' não pode ser nulo");
        this.data = data;
    }
    
    /**
     *
     * Realiza a conversão dos formatos de data caso for String
     * @param datasPlanilha - Formatos de datas prontos.
     * @param data 
     */
    CampoData(FormatoDatasPlanilha dp, String data) {
        this.dp = Objects.requireNonNull(dp, "O campo 'datasPlanilha' não pode ser nulo");
        this.valorOriginal = data;

        try {
            if (data == null) {
                 return;
            }
               
            else {
                if (PADRAO_DATA_M_D_YY.matcher(data).matches()) {
                    this.data = dp.converterNoFormatoMesDiaAno(data);
                }
                else {
                    if (PADRAO_DATA_D_M_YYYY.matcher(data).matches()) {
                        this.data = dp.converterNoFormatoDiaMesAno(data);
                    }
                
                }
            
            }       
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    public static Campo<Date> nulo() {
        return CAMPO_NULO;
    }

    @Override
    public Optional<String> valorOriginal() {
        if (valorOriginal == null && data != null)
            valorOriginal = dp.formatoDD_MM_YYYY(data);
        return Optional.ofNullable(valorOriginal);
    }
}

Eu estou tentando fazer quando o estilo da célula for preenchido com dd/MM/yyyy ele permita validar, quando nesse cara cell.getDateCellValue(), vier o estilo da célula preenchido dd/MM/yyyy.