Bessere Nutzung von Enums unter Java 8

In unserer Cloud-Nutzungsanalyse-API werden formatierte Analysedaten zurückgegeben (hier bezieht sich auf die Erstellung von Analysediagrammen). Kürzlich haben wir eine Funktion hinzugefügt, mit der Benutzer einen Zeitraum auswählen können (zunächst nur nach Tag). Das Problem besteht darin, dass der Zeitraum jedes Tages im Code stark gekoppelt ist...

Zum Beispiel der folgende Code:

private static List<DataPoint> createListWithZerosForTimeInterval(DateTime from,
    DateTime to,
    ImmutableSet<Metric<? extends Number>> metrics) {
    List<DataPoint> points = new ArrayList<>();
    for (int i = 0; i <= Days.daysBetween(from, to).getDays(); i++) {
        points.add(new DataPoint().withDatas(createDatasWithZeroValues(metrics))
            .withDayOfYear(from.withZone(DateTimeZone.UTC)
                .plusDays(i)
                .withTimeAtStartOfDay()));
    }
    return points;
}

Hinweis: Tage, Minuten, Stunden, Wochen und Monate erscheinen später im Code. Dieser Code stammt von der Joda-Time Java-Zeit- und Datums-API. Selbst die Namen der Methoden spiegeln nicht (ihre jeweilige Funktionalität) wider. Diese Namen sind fest mit dem Begriff der Tage verbunden.

Ich habe auch versucht, verschiedene Zeiträume (z. B. Monate, Wochen, Stunden) zu verwenden. Aber ich habe gesehen, dass sich im Code fehlerhafte Schalter/Fälle herumschleichen.

Sie müssen wissen, dass switch/case=sin tief in mein Herz eingedrungen ist. Das dachte ich mir schon während meiner beiden Praktika während des Studiums. Daher würde ich Switch/Case unbedingt vermeiden. Dies liegt vor allem daran, dass sie gegen das Offen-Geschlossen-Prinzip verstoßen. Ich bin fest davon überzeugt, dass die Befolgung dieses Prinzips die beste Vorgehensweise beim Schreiben von objektorientiertem Code ist. Ich bin nicht der Einzige, der so denkt, Robert C. Martin hat einmal gesagt:

In vielerlei Hinsicht ist das Offen-Geschlossen-Prinzip der Kern des objektorientierten Designs. Die Befolgung dieses Prinzips wird enorme Vorteile aus objektorientierten Techniken wie Wiederverwendbarkeit und Wartbarkeit ziehen1.

Ich sagte mir: „Vielleicht können wir mithilfe von Java8 einige neue Funktionen entdecken, um gefährliche Wechsel-/Gehäuseszenen zu vermeiden.“ Nutzen Sie die neuen Funktionen von Java 8 (nicht so neu, aber Sie wissen, was ich meine). Ich habe mich entschieden, eine Enumeration zu verwenden, um die verschiedenen verfügbaren Zeiträume darzustellen.

public enum TimePeriod
{
    MINUTE(Dimension.MINUTE,
           (from,
            to) -> Minutes.minutesBetween(from, to).getMinutes() + 1,
           Minutes::minutes,
           from -> from.withZone(DateTimeZone.UTC)
                       .withSecondOfMinute(0)
                       .withMillisOfSecond(0)),
    HOUR(Dimension.HOUR,
         (from,
          to) -> Hours.hoursBetween(from, to).getHours() + 1,
         Hours::hours,
         from -> from.withZone(DateTimeZone.UTC)
                     .withMinuteOfHour(0)
                     .withSecondOfMinute(0)
                     .withMillisOfSecond(0)),
    DAY(Dimension.DAY,
        (from,
         to) -> Days.daysBetween(from, to).getDays() + 1,
        Days::days,
        from -> from.withZone(DateTimeZone.UTC)
                    .withTimeAtStartOfDay()),
    WEEK(Dimension.WEEK,
         (from,
          to) -> Weeks.weeksBetween(from, to).getWeeks() + 1,
         Weeks::weeks,
         from -> from.withZone(DateTimeZone.UTC)
                     .withDayOfWeek(1)
                     .withTimeAtStartOfDay()),
    MONTH(Dimension.MONTH,
          (from,
           to) -> Months.monthsBetween(from, to).getMonths() + 1,
          Months::months,
          from -> from.withZone(DateTimeZone.UTC)
                      .withDayOfMonth(1)
                      .withTimeAtStartOfDay());
 
    private Dimension<Timestamp> dimension;
    private BiFunction<DateTime, DateTime, Integer> getNumberOfPoints;
    private Function<Integer, ReadablePeriod> getPeriodFromNbOfInterval;
    private Function<DateTime, DateTime> getStartOfInterval;
 
    private TimePeriod(Dimension<Timestamp> dimension,
                       BiFunction<DateTime, DateTime, Integer> getNumberOfPoints,
                       Function<Integer, ReadablePeriod> getPeriodFromNbOfInterval,
                       Function<DateTime, DateTime> getStartOfInterval)
    {
        this.dimension = dimension;
        this.getNumberOfPoints = getNumberOfPoints;
        this.getPeriodFromNbOfInterval = getPeriodFromNbOfInterval;
        this.getStartOfInterval = getStartOfInterval;
    }
 
    public Dimension<Timestamp> getDimension()
    {
        return dimension;
    }
 
    public int getNumberOfPoints(DateTime from,
                                 DateTime to)
    {
        return getNumberOfPoints.apply(from, to);
    }
 
    public ReadablePeriod getPeriodFromNbOfInterval(int nbOfInterval)
    {
        return getPeriodFromNbOfInterval.apply(nbOfInterval);
    }
 
    public DateTime getStartOfInterval(DateTime from)
    {
        return getStartOfInterval.apply(from);
    }
}

Mit der Aufzählung konnte ich den Code einfach ändern, um dem Benutzer die Angabe eines Zeitraums für die Diagrammdatenpunkte zu ermöglichen.

Es stellte sich heraus, dass es so hieß:

for (int i = 0; i <= Days.daysBetween(from, to).getDays(); i++)

Es wurde so genannt:

for (int i = 0; i < timePeriod.getNumberOfPoints(from, to); i++)

Der Usage Analytics-Dienstcode, der getGraphDataPoints-Aufrufe unterstützt, lautete abgeschlossen und unterstützt Zeiträume. Es ist erwähnenswert, dass es das zuvor erwähnte Offen-Geschlossen-Prinzip berücksichtigt.