Java - Элегантный способ синтаксического анализа даты/периода?

Ответ 1

Там нет реального противостояния этому расщеплению. Oracle разделила обязанности этих отдельных парсеров, и если мы хотим использовать их вместе в таком оркестровке, мы должны убедиться, что мы очистим части вместе разумным образом.

Тем не менее, у меня есть решение, которое работает с ядром Java 8 и использует Function и несколько пользовательских классов. Я буду опускать пользовательский beans для краткости, поскольку они довольно простые, а также тот факт, что основной лифт выполняется в Function s.

Обратите внимание, что для того, чтобы получить "Z", чтобы быть признанным как действительная запись, вам нужно проанализировать с помощью DateTimeFormatter.ISO_DATE_TIME. Кроме того, чтобы обеспечить надлежащую подборку продолжительности, добавьте "PT" к тексту, который будет соответствовать длительности. Более разумный способ получить эту деталь из существующей строки - это упражнение, которое я оставляю читателю.

Function<String, Range> convertToRange = (dateString) -> {

    String[] dateStringParts = dateString.split("/");
    return new Range(LocalDateTime.parse(dateStringParts[0], DateTimeFormatter.ISO_DATE_TIME),
            LocalDateTime.parse(dateStringParts[1], DateTimeFormatter.ISO_DATE_TIME));
};

Function<String, DurationAndDateTime> convertToDurationAndDateTime = (dateString) -> {
    String[] dateStringParts = dateString.split("/");
    String[] durationAndPeriodParts = dateStringParts[1].split("T");
    return new DurationAndDateTime(Period.parse(durationAndPeriodParts[0]),
            Duration.parse("PT" + durationAndPeriodParts[1]),
            LocalDateTime.parse(dateStringParts[0], DateTimeFormatter.ISO_DATE_TIME));
};


Function<String, DurationAndDateTime> convertToDateTimeAndDuration = (dateString) -> {
    String[] dateStringParts = dateString.split("/");
    String[] durationAndPeriodParts = dateStringParts[0].split("T");
    return new DurationAndDateTime(Period.parse(durationAndPeriodParts[0]),
            Duration.parse("PT" + durationAndPeriodParts[1]),
            LocalDateTime.parse(dateStringParts[1], DateTimeFormatter.ISO_DATE_TIME));
};

Function<String, DurationOnly> convertToDurationOnlyRelativeToCurrentTime = (dateString) -> {
    String[] durationAndPeriodParts = dateString.split("T");
    return new DurationOnly(Period.parse(durationAndPeriodParts[0]),
            Duration.parse("PT" + durationAndPeriodParts[1]));
};

Ответ 2

Я рад решить вашу проблему, так как это хороший пример для введения Composite Design Pattern в Функциональное программирование. вы можете создавать функции в большую и мощную единую функцию. например:

Function<String, Optional<Range<LocalDateTime>>> parser = anyOf(
        both(), //case 1
        starting(), //case 2
        ending(), //case 3
        since(LocalDateTime.now()) //case 4
);

Range<LocalDateTime> range = parser.apply("<INPUT>").orElse(null);

//OR using in stream as below
List<Range<LocalDateTime>> result = Stream.of(
    "<Case 1>", "<Case 2>", "<Case 3>", "<Case 4>"
).map(parser).filter(Optional::isPresent).map(Optional::get).collect(toList());

Введем код выше каждого шага

приведенный ниже код почти применяет большинство Design Patterns в ООП. например: composite, proxy, adapter, Factory Метод Шаблоны проектирования и .etc.

Функции

factory: метод both соответствует первому случаю, как показано ниже:

static Function<String, Optional<Range<LocalDateTime>>> both() {
    return parsing((first, second) -> new Range<>(
            datetime(first),
            datetime(second)
    ));
}

factory: метод starting соответствует второму случаю, как показано ниже:

static Function<String, Optional<Range<LocalDateTime>>> starting() {
        return parsing((first, second) -> {
            LocalDateTime start = datetime(first);
            return new Range<>(start, start.plus(amount(second)));
        });
    }

factory: метод ending соответствует 3-му случаю, как показано ниже:

static Function<String, Optional<Range<LocalDateTime>>> ending() {
    return parsing((first, second) -> {
        LocalDateTime end = datetime(second);
        return new Range<>(end.minus(amount(first)), end);
    });
}

factory: метод since встречается в последнем случае, как показано ниже:

static Function<String,Optional<Range<LocalDateTime>>> since(LocalDateTime start) {
    return parsing((amount, __) -> new Range<>(start, start.plus(amount(amount))));
}

composite: ответственность метода anyOf заключается в том, чтобы как можно быстрее найти удовлетворительный результат среди Function:

@SuppressWarnings("ConstantConditions")
static <T, R> Function<T, Optional<R>>
anyOf(Function<T, Optional<R>>... functions) {
    return it -> Stream.of(functions).map(current -> current.apply(it))
            .filter(Optional::isPresent)
            .findFirst().get();
}

adapter: ответственность метода parsing заключается в создании парсера для определенного ввода:

static <R> Function<String, Optional<R>> 
parsing(BiFunction<String, String, R> parser) {
    return splitting("/", exceptionally(optional(parser), Optional::empty));
}

proxy: ответственность метода exceptionally обрабатывается Exception s:

static <T, U, R> BiFunction<T, U, R>
exceptionally(BiFunction<T, U, R> source, Supplier<R> exceptional) {
    return (first, second) -> {
        try {
            return source.apply(first, second);
        } catch (Exception ex) {
            return exceptional.get();
        }
    };
}

adapter: ответственность метода splitting переводится как BiFunction в Function:

static <R> Function<String, R>
splitting(String regex, BiFunction<String, String, R> source) {
    return value -> {
        String[] parts = value.split(regex);
        return source.apply(parts[0], parts.length == 1 ? "" : parts[1]);
    };
}

adapter: ответственность за метод optional заключается в создании optional для окончательного результата:

static <R> BiFunction<String, String, Optional<R>> 
optional(BiFunction<String, String, R> source) {
    return (first, last) -> Optional.of(source.apply(first, last));
}

Объект значения:

класс Range для сохранения вещи в диапазоне:

final class Range<T> {
    public final T start;
    public final T end;

    public Range(T start, T end) {
        this.start = start;
        this.end = end;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Range)) {
            return false;
        }
        Range<?> that = (Range<?>) o;

        return Objects.equals(start, that.start) && Objects.equals(end, that.end);
    }


    @Override
    public int hashCode() {
        return Objects.hash(start) * 31 + Objects.hash(end);
    }

    @Override
    public String toString() {
        return String.format("[%s, %s]", start, end);
    }
}

Утилиты

метод datetime создает LocalDateTime из String:

static LocalDateTime datetime(String datetime) {
    return LocalDateTime.parse(
            datetime, 
            DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss['Z']")
    );
}    

метод amount создает TemporalAmount, который принимает как Duration, так и Period от String:

static TemporalAmount amount(String text) {
    return splitting("T", (first, second) -> new TemporalAmount() {
        private Period period= first.isEmpty() ? Period.ZERO : Period.parse(first);
        private Duration duration = second.isEmpty() ? Duration.ZERO
                : Duration.parse(String.format("PT%s", second));

        @Override
        public long get(TemporalUnit unit) {
            return (period.getUnits().contains(unit) ? period.get(unit) : 0) +
                   (duration.getUnits().contains(unit) ? duration.get(unit) : 0);
        }

        @Override
        public List<TemporalUnit> getUnits() {
            return Stream.of(period, duration).map(TemporalAmount::getUnits)
                                              .flatMap(List::stream)
                                              .collect(toList());
        }

        @Override
        public Temporal addTo(Temporal temporal) {
            return period.addTo(duration.addTo(temporal));
        }

        @Override
        public Temporal subtractFrom(Temporal temporal) {
            return period.subtractFrom(duration.subtractFrom(temporal));
        }
    }).apply(text);
}