Paul Marcelin Bejan's questions

Sei que isso pode parecer estranho após 3 anos de desenvolvimento de software, mas estou tentando entender melhor as classes java.time e como usá-las para evitar erros e práticas inadequadas.

No primeiro projeto em que estive envolvido, a versão java utilizada foi a 8, mas os valores de data foram armazenados na classe legada java.util.Date

Dois anos depois, nova empresa, novo projeto com java versão 17, mas ainda valores de data são armazenados na classe legada java.util.Date

A confusão começou quando vi que havia um DateUtils no projeto com métodos como:

public static String toString_ddMMyyyy_dotted(Date date){
    LocalDateTime localDateTime = date.toInstant().atZone(ZoneId.systemDefualt()).toLocalDateTime();
    DateTimeFormatter.ofPattern("dd.MM.yyyy").format(localDateTime);
}

public static Date getBeginOfTheYear(Date date){
    LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefualt()).toLocalDate();
    LocalDate beginOfTheYear = localDate.withMonth(1).withDayOfMonth(1);
    return Date.from(beginOfTheYear.atStartOfDay().atZone(ZoneId.systemDefault()).toInstant());
}

Então minha pergunta foi: por que não usar diretamente as classes java.time que possuem APIs realmente boas em vez de converter uma variável em LocalDate/LocalDateTime sempre que uma operação na Data for necessária?

A ideia é refatorar o projeto o mais rápido possível para armazenar valores de Data/DataHora/Hora em classes java.time. Comecei com um módulo simples, que salva alguns dados no MongoDB. Apliquei a seguinte conversão de tipo de campo:

• Valores de data em LocalDate
• Valores de data e hora em LocalDateTime

Durante o teste, encontrei imediatamente um problema, uma variável localDateTime com valor de 2023-10-07 12:00:00 foi salva no MongoDB como 2023-10-07 10:00:00 Isso não é um problema, desde que os dados é buscado de volta em java, o valor volta para 2023-10-07 12:00:00, mas isso não está acontecendo, então é um grande problema.

Primeiramente, isso acontece apenas com o LocalDateTime ou também acontece com o LocalDate?

Quais são as melhores práticas para armazenar valores de data/data e hora em classes de entidade/documento? Devo usar ZonedDateTime em vez de LocalDateTime?

Estou criando uma anotação para validar as datas de início/término, quero garantir que elas não se sobreponham.

Anotação:

@Documented
@Target({ ElementType.TYPE, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = { NonOverlappingDatesValidator.class })
public @interface NonOverlappingDates {

    String start();
    String end();

    String message() default "OVERLAPPING_OF_DATES";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
    
}

Validador:

public class NonOverlappingDatesValidator implements ConstraintValidator<NonOverlappingDates, Object> {

    private String start;

    private String end;

    /**
     * Initialize.
     */
    @Override
    public void initialize(NonOverlappingDates nonOverlappingDates) {
        start = nonOverlappingDates.start();
        end = nonOverlappingDates.end();
    }

    /**
     * Checks if is valid.
     */
    @Override
    public boolean isValid(Object instanceToValidate, ConstraintValidatorContext constraintValidatorContext) {
        Class<?> classToValidate = instanceToValidate.getClass();
        
        LocalDateTime startDate;
        LocalDateTime endDate;
        
        try {
            startDate = getLocalDateTimeFromFieldName(classToValidate, instanceToValidate, start);
            endDate = getLocalDateTimeFromFieldName(classToValidate, instanceToValidate, end);
        } catch (ReflectionException e) {
            throw new RuntimeException(e);
        }
        
        return DateTimeUtils.isBefore(startDate, endDate);
    }
    
    private LocalDateTime getLocalDateTimeFromFieldName(Class<?> classToValidate, Object instanceToValidate, String fieldName) throws ReflectionException {
        Method getter = ReflectionUtils.getPublicGetterOfFieldName(classToValidate, fieldName);
        Object value = ReflectionUtils.invokeMethod(instanceToValidate, getter);
        if (value instanceof LocalDateTime localDateTime) {
            return localDateTime;
        } else {
            throw new RuntimeException(fieldName+" is not a LocalDateTime");
        }
    }

}

DTO a ser validado:

@Data
@NonOverlappingDates(start = "startDate", end = "endDate")
public class IdentityCardDTO {

    @JsonProperty
    private Long id;

    @JsonProperty
    private String name;

    @JsonProperty
    private String surname;

    @JsonProperty
    @JsonSerialize(using = LocalDateSerializer.class)
    @JsonDeserialize(using = LocalDateDeserializer.class)
    private LocalDate dateOfBirth;

    @JsonProperty
    @JsonSerialize(using = LocalDateTimeSerializer.class)
    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
    private LocalDateTime startDate;

    @JsonProperty
    @JsonSerialize(using = LocalDateTimeSerializer.class)
    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
    private LocalDateTime endDate;
    
}

Gostaria de saber se ao invés de passar o nome dos campos e depois usar o Reflection para recuperar o valor, é possível passar diretamente o valor dos campos que quero validar.