Joda Time LocalTime de 24:00 en fin de journée

La solution que nous avons finalement allé avec était d'utiliser 00:00 à 24:00, avec une logique tout au long de la classe et le reste de l'application d'interpréter cette valeur locale. C'est un vrai bidouille, mais c'est le moins intrusif et le plus élégant de chose que je pouvais venir.

Tout d'abord, le LocalTimeInterval classe conserve un indicateur interne de savoir si l'intervalle de point de terminaison est en fin de journée à minuit (24:00). Cet indicateur n'est vrai que si l'heure de fin de 00:00 (égal à LocalTime.MINUIT).

/**
 * @return Whether the end of the day is {@link LocalTime#MIDNIGHT} and this should be considered midnight of the
 *         following day.
 */
public boolean isEndOfDay()
{
    return isEndOfDay;
}

Par défaut, le constructeur estime 00:00 pour être en début de journée, mais il y a un autre constructeur pour la création manuelle d'un intervalle qui va tous les jours:

public LocalTimeInterval(final LocalTime start, final LocalTime end, final boolean considerMidnightEndOfDay)
{
    ...
    this.isEndOfDay = considerMidnightEndOfDay && LocalTime.MIDNIGHT.equals(end);
}

Il ya une raison pourquoi ce constructeur n'est pas seulement un temps de début et un "est en fin de journée" drapeau: lorsqu'il est utilisé avec une INTERFACE utilisateur avec une liste déroulante de fois, nous ne savons pas si l'utilisateur choisit 00:00 (ce qui est rendu de 24:00), mais nous savons que si la liste déroulante est pour la fin de la plage, dans notre cas d'utilisation, cela signifie 24:00. (Bien que LocalTimeInterval permet des intervalles vides, nous ne leur permettons pas à notre demande.)

Chevauchement de la vérification nécessite une logique spéciale pour prendre soin de 24:00:

public boolean overlaps(final LocalTimeInterval localInterval)
{
    if (localInterval.isEndOfDay())
    {
        if (isEndOfDay())
        {
            return true;
        }
        return getEnd().isAfter(localInterval.getStart());
    }
    if (isEndOfDay())
    {
        return localInterval.getEnd().isAfter(getStart());
    }
    return localInterval.getEnd().isAfter(getStart()) && localInterval.getStart().isBefore(getEnd());
}

De même, la conversion à un Intervalle absolu nécessite l'ajout d'un autre jour pour le résultat, si isEndOfDay() renvoie la valeur true. Il est important que le code de l'application ne jamais construit un Intervalle manuellement à partir d'un LocalTimeInterval de début et de fin des valeurs, comme la fin des temps peut indiquer la fin de la journée:

public Interval toInterval(final ReadableInstant baseInstant)
{
    final DateTime start = getStart().toDateTime(baseInstant);
    DateTime end = getEnd().toDateTime(baseInstant);
    if (isEndOfDay())
    {
        end = end.plusDays(1);
    }
    return new Interval(start, end);
}

Lors de la persistance LocalTimeInterval dans la base de données, nous avons été en mesure de faire de la bidouille totalement transparent, que la mise en veille et SQL ont pas de 24:00 restriction (et n'ont aucune notion de LocalTime de toute façon). Si isEndOfDay() renvoie true, notre PersistentLocalTimeIntervalAsTime mise en œuvre stocke et récupère une vrai valeur de temps de 24:00:

    ...
    final Time startTime = (Time) Hibernate.TIME.nullSafeGet(resultSet, names[0]);
    final Time endTime = (Time) Hibernate.TIME.nullSafeGet(resultSet, names[1]);
    ...
    final LocalTime start = new LocalTime(startTime, DateTimeZone.UTC);
    if (endTime.equals(TIME_2400))
    {
        return new LocalTimeInterval(start, LocalTime.MIDNIGHT, true);
    }
    return new LocalTimeInterval(start, new LocalTime(endTime, DateTimeZone.UTC));

et

    final Time startTime = asTime(localTimeInterval.getStart());
    final Time endTime = localTimeInterval.isEndOfDay() ? TIME_2400 : asTime(localTimeInterval.getEnd());
    Hibernate.TIME.nullSafeSet(statement, startTime, index);
    Hibernate.TIME.nullSafeSet(statement, endTime, index + 1);

Il est triste de constater que nous avons eu à écrire une solution de contournement, en premier lieu, c'est le meilleur que je pouvais faire.

Ce n'est pas un défaut de conception. LocalDate ne gère pas les (24,0) car il n'y a pas une telle chose comme 24:00.

Aussi, ce qui arrive quand vous voulez représenter un intervalle entre 9h et 3h du matin?

Quel est le problème avec ceci:

new LocalInterval(new LocalTime(23, 0), new LocalTime(0, 0));

Vous suffit de manipuler la possibilité que le temps de la fin, peut-être "avant" l'heure de début, et ajouter un jour lorsque nécessaire, et espère juste que personne ne veut représenter un intervalle de plus de 24 heures.

Sinon, représentent l'intervalle de la combinaison d'une LocalDate et un Duration ou Period. Qui enlève les "plus de 24 heures" problème.

Le temps de 24:00 est difficile. Alors que nous, les humains peuvent comprendre ce qu'on entend, le codage d'une API pour la représenter, sans nuire à tout le reste me paraît presque impossible.

La valeur 24 nullité est profondément codé en Joda-Time - essayez de l'enlever aurait des répercussions négatives dans beaucoup d'endroits. Je ne vous recommande pas d'essayer de le faire.

Pour votre problème, les locaux de l'intervalle doit être composé soit d' (LocalTime, LocalTime, Days) ou (LocalTime, Period). Ce dernier est légèrement plus souple. Ceci est nécessaire pour correctement prendre en charge un intervalle à partir de 23:00 à 03:00.

c'est notre mise en œuvre de TimeInterval, utiliser la valeur null à la Date de fin de fin de journée. Il prend en charge les chevauchements() et() les méthodes et repose également sur la joda-time. Il prend en charge les intervalles s'étendant sur plusieurs jours.

/**
* Description: Immutable time interval<br>
* The start instant is inclusive but the end instant is exclusive.
* The end is always greater than or equal to the start.
* The interval is also restricted to just one chronology and time zone.
* Start can be null (infinite).
* End can be null and will stay null to let the interval last until end-of-day.
* It supports intervals spanning multiple days.
*/
public class TimeInterval {
public static final ReadableInstant INSTANT = null; //null means today
//   public static final ReadableInstant INSTANT = new Instant(0); //this means 1st jan 1970
private final DateTime start;
private final DateTime end;
public TimeInterval() {
this((LocalTime) null, null);
}
/**
* @param from - null or a time  (null = left unbounded == LocalTime.MIDNIGHT)
* @param to   - null or a time  (null = right unbounded)
* @throws IllegalArgumentException if invalid (to is before from)
*/
public TimeInterval(LocalTime from, LocalTime to) throws IllegalArgumentException {
this(from == null ? null : from.toDateTime(INSTANT),
to == null ? null : to.toDateTime(INSTANT));
}
/**
* create interval spanning multiple days possibly.
*
* @param start - start distinct time
* @param end   - end distinct time
* @throws IllegalArgumentException - if start > end. start must be <= end
*/
public TimeInterval(DateTime start, DateTime end) throws IllegalArgumentException {
this.start = start;
this.end = end;
if (start != null && end != null && start.isAfter(end))
throw new IllegalArgumentException("start must be less or equal to end");
}
public DateTime getStart() {
return start;
}
public DateTime getEnd() {
return end;
}
public boolean isEndUndefined() {
return end == null;
}
public boolean isStartUndefined() {
return start == null;
}
public boolean isUndefined() {
return isEndUndefined() && isStartUndefined();
}
public boolean overlaps(TimeInterval other) {
return (start == null || (other.end == null || start.isBefore(other.end))) &&
(end == null || (other.start == null || other.start.isBefore(end)));
}
public boolean contains(TimeInterval other) {
return ((start != null && other.start != null && !start.isAfter(other.start)) || (start == null)) &&
((end != null && other.end != null && !other.end.isAfter(end)) || (end == null));
}
public boolean contains(LocalTime other) {
return contains(other == null ? null : other.toDateTime(INSTANT));
}
public boolean containsEnd(DateTime other) {
if (other == null) {
return end == null;
} else {
return (start == null || !other.isBefore(start)) &&
(end == null || !other.isAfter(end));
}
}
public boolean contains(DateTime other) {
if (other == null) {
return start == null;
} else {
return (start == null || !other.isBefore(start)) &&
(end == null || other.isBefore(end));
}
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder();
sb.append("TimeInterval");
sb.append("{start=").append(start);
sb.append(", end=").append(end);
sb.append('}');
return sb.toString();
}
}

Cette question est ancienne, mais beaucoup de ces réponses se concentrent sur Joda Temps, et en partie seulement aborder le vrai problème sous-jacent:

Le modèle dans le cas des OP code ne correspond pas à la réalité, c'est la modélisation.

Malheureusement, puisque vous ne semblent se soucier de la condition à la limite entre les jours, votre "autrement élégant modèle" n'est pas un bon match pour le problème de la modélisation. Vous avez utilisé une paire de valeurs de temps pour représenter les intervalles. Tenter de simplifier le modèle vers le bas pour une paire de fois est de simplifier en dessous de la complexité du monde réel problème. Les limites de la journée en fait n'existent pas dans la réalité et une paire de fois perd ce type d'informations. Comme toujours, sur la simplification des résultats dans la suite de la complexité de restaurer ou compenser pour le manque d'informations. Réelle complexité ne peut être poussé autour d'une partie du code à l'autre.

La complexité de la réalité ne peut être éliminé à la magie de la "non prise en charge des cas d'utilisation".

Votre modèle n'a de sens que dans un espace-problème où l'on n'a pas de soins de combien de jours peuvent exister entre le début et la fin des temps. Le problème de l'espace ne correspond pas à la plupart des problèmes du monde réel. Par conséquent, il n'est pas surprenant que Joda Temps, ne le supporte pas bien. L'utilisation de 25 valeurs pour les heures place (0-24) est un odeur de code et généralement des points de faiblesse dans la conception. Il y a seulement 24 heures dans la journée pour 25 valeurs ne doivent pas être besoin!

Noter que, puisque vous n'êtes pas capturer de la date de la fin de l' LocalIntervalvotre classe également ne pas obtenir suffisamment d'information pour tenir compte de l'heure d'été. [00:30:00 TO 04:00:00) est généralement de 3,5 heures, mais pourrait également être de 2,5, ou 4,5 heures de temps.

Vous devez soit utiliser une date/heure de début et la durée, ou à une date/heure de début et une date/heure de fin (inclus démarrer, exclusive est un bon choix par défaut). À l'aide d'une durée devient difficile si vous avez l'intention d'afficher l'heure de fin à cause de choses comme l'heure d'été, les années bissextiles et les secondes intercalaires. Sur l'autre main à l'aide d'une date de fin devient tout aussi difficile si vous prévoyez d'afficher la durée. Stocker à la fois des cours est dangereux parce qu'il viole les Principe SEC. Si j'avais écrit une telle classe je voudrais stocker une date/heure de fin et encapsulent la logique de l'obtention de la durée par l'intermédiaire d'une méthode sur l'objet. De cette façon, les clients de la classe de la classe ne sont pas tous venir avec leur propre code pour calculer la durée.

J'avais le code d'un exemple, mais il y a une option encore meilleure. L'utilisation de la norme Intervalle de Classe de Joda time, qui accepte d'ores et déjà un démarrage instantané et soit la durée ou à la fin de l'instantané. Il sera également et heureusement calculer la durée ou l'heure de fin pour vous. Malheureusement JSR 310 ne pas avoir un intervalle ou d'une catégorie similaire. (bien que l'on peut utiliser ThreeTenExtra à faire pour que)

Relativement lumineux gens à Joda Temps et de Sun/Oracle (JSR 310) à la fois très soigneusement réfléchi à ces problèmes. Vous pourriez être plus intelligent qu'eux. Il est possible de faire. Cependant, même si vous êtes un des plus lumineux de l'ampoule, votre 1 heure ne va probablement pas à accomplir ce qu'ils ont passé des années sur. Sauf si vous êtes quelque part dans un ésotérisme bord de cas, il est généralement gaspillage de temps et d'argent à dépenser l'effort de deuxième deviner. (bien sûr, au moment de l'OP JSR 310 n'était pas complet...)

Espérons-le, ci-dessus va aider les gens qui trouvent cette question lors de la conception ou de la fixation des problèmes similaires.