Abfrage von Entitäten nach Datum und Uhrzeit mit Spring Data JPA

Abfragen von Entitäten nach Datum und Uhrzeit mit Spring Data JPA

1. Einführung

In diesem kurzen Tutorial erfahren Sie, wie Sie mit Spring Data JPA Entitäten nach Datum abfragen.

Wir werden zunächst unser Gedächtnis darüber auffrischen, wie Datum und Uhrzeit mit JPA zugeordnet werden.

Anschließend erstellen wir eine Entität mit Datums- und Zeitfeldern sowie ein Spring Data-Repository, um diese Entitäten abzufragen.

2. Daten und Zeiten mit JPA zuordnen

Für den Anfangwe’ll review a bit of theory about mapping dates with JPA. Zu wissen ist, dass wir uns entscheiden müssen, ob wir vertreten wollen:

Nur ein Datum
Nur eine Zeit
Oder beides

Zusätzlich zur Annotation (optional)@Columnmüssen wir die Annotation@Temporalhinzufügen, um anzugeben, was das Feld darstellt.

Diese Annotation nimmt einen Parameter an, der einen Wert vonTemporalType enum hat:

TemporalType.DATE
TemporalType.TIME
TemporalType.TIMESTAMP

Ein ausführlicher Artikel über die Zuordnung von Datum und Uhrzeit mit JPA finden Sie unterhere.

3. In der Praxis

In der Praxis ist nach der korrekten Einrichtung unserer Entitäten nicht viel Arbeit erforderlich, um sie mit Spring Data JPA abzufragen. Wir müssen nurquery methods, @Query annotation verwenden.

Every Spring Data JPA mechanism will work just fine.

Sehen wir uns einige Beispiele für Entitäten an, die mit Spring Data JPA nach Datum und Uhrzeit abgefragt wurden.

3.1. Eine Entität einrichten

Nehmen wir zunächst an, wir haben eineArticle-Entität mit einem Veröffentlichungsdatum, einer Veröffentlichungszeit sowie einem Erstellungsdatum und einer Erstellungszeit:

@Entity
public class Article {

    @Id
    @GeneratedValue
    Integer id;

    @Temporal(TemporalType.DATE)
    Date publicationDate;

    @Temporal(TemporalType.TIME)
    Date publicationTime;

    @Temporal(TemporalType.TIMESTAMP)
    Date creationDateTime;
}

Wir teilen Datum und Uhrzeit der Veröffentlichung zu Demonstrationszwecken in zwei Felder auf. Auf diese Weise werden die drei Zeittypen dargestellt.

3.2. Fragen Sie die Entitäten ab

Nachdem unsere Entität eingerichtet ist, erstellen wir Spring Datarepository, um diese Artikel abzufragen.

Wir erstellen drei Methoden mit mehreren Spring Data JPA-Funktionen:

public interface ArticleRepository
  extends JpaRepository {

    List findAllByPublicationDate(Date publicationDate);

    List findAllByPublicationTimeBetween(
      Date publicationTimeStart,
      Date publicationTimeEnd);

    @Query("select a from Article a where a.creationDateTime <= :creationDateTime")
    List findAllWithCreationDateTimeBefore(
      @Param("creationDateTime") Date creationDateTime);

}

Also haben wir drei Methoden definiert:

findAllByPublicationDate, mit dem Artikel abgerufen werden, die an einem bestimmten Datum veröffentlicht wurden
findAllByPublicationTimeBetween, mit dem Artikel abgerufen werden, die zwischen zwei Stunden veröffentlicht wurden
undfindAllWithCreationDateTimeBefore, die Artikel abrufen, die vor einem bestimmten Datum und einer bestimmten Uhrzeit erstellt wurden

Die beiden ersten Methoden basieren auf dem Mechanismus von Spring Dataquery methodsund die letzte auf der Annotation von@Query.

Dies ändert letztendlich nichts an der Art und Weise, wie Daten behandelt werden. The first method will only consider the date part of the parameter.

Die Sekunde berücksichtigt nur die Zeit der Parameter. Und der letzte verwendet sowohl Datum als auch Uhrzeit.

3.3. Testen Sie die Abfragen

Als letztes müssen wir einige Tests einrichten, um zu überprüfen, ob diese Abfragen wie erwartet funktionieren.

Wir importieren zuerst einige Daten in unsere Datenbank und erstellen dann die Testklasse, die jede Methode des Repositorys überprüft:

@RunWith(SpringRunner.class)
@DataJpaTest
public class ArticleRepositoryIntegrationTest {

    @Autowired
    private ArticleRepository repository;

    @Test
    public void whenFindByPublicationDate_thenArticles1And2Returned() {
        List result = repository.findAllByPublicationDate(
          new SimpleDateFormat("yyyy-MM-dd").parse("2018-01-01"));

        assertEquals(2, result.size());
        assertTrue(result.stream()
          .map(Article::getId)
          .allMatch(id -> Arrays.asList(1, 2).contains(id)));
    }

    @Test
    public void whenFindByPublicationTimeBetween_thenArticles2And3Returned() {
        List result = repository.findAllByPublicationTimeBetween(
          new SimpleDateFormat("HH:mm").parse("15:15"),
          new SimpleDateFormat("HH:mm").parse("16:30"));

        assertEquals(2, result.size());
        assertTrue(result.stream()
          .map(Article::getId)
          .allMatch(id -> Arrays.asList(2, 3).contains(id)));
    }

    @Test
    public void givenArticlesWhenFindWithCreationDateThenArticles2And3Returned() {
        List result = repository.findAllWithCreationDateTimeBefore(
          new SimpleDateFormat("yyyy-MM-dd HH:mm").parse("2017-12-15 10:00"));

        assertEquals(2, result.size());
        assertTrue(result.stream()
          .map(Article::getId)
          .allMatch(id -> Arrays.asList(2, 3).contains(id));
    }
}

Bei jedem Test wird überprüft, ob nur die Artikel abgerufen werden, die den Bedingungen entsprechen.

4. Fazit

In diesem kurzen Artikel haben wir gesehen, wie Entitäten mithilfe ihrer Datums- und Uhrzeitfelder mit Spring Data JPA abgefragt werden.

Wir haben ein bisschen Theorie gelernt, bevor wir Spring Data-Mechanismen zum Abfragen der Entitäten verwendeten. Wir haben gesehen, dass diese Mechanismen mit Datum und Uhrzeit genauso funktionieren wie mit anderen Datentypen.

Der Quellcode für diesen Artikel istover on GitHub verfügbar.

TOC