Fragen Sie Entitäten nach Datum und Uhrzeit mit Spring Data JPA ab

1. Einleitung

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

Wir werden zuerst unser Gedächtnis darüber auffrischen, wie Datum und Uhrzeit mit JPA abgebildet werden.

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

2. Zuordnen von Daten und Zeiten mit JPA

Für den Anfang werden wir ein wenig Theorie über das Zuordnen von Daten mit JPA überprüfen . Zu wissen ist, dass wir uns entscheiden müssen, ob wir repräsentieren wollen:

  • Nur ein Datum
  • Nur eine Zeit
  • Oder beides

Zusätzlich zur (optionalen) @ Column- Annotation müssen wir die @ Temporal- Annotation hinzufügen, um anzugeben, was das Feld darstellt.

Diese Annotation nimmt einen Parameter an, der ein Wert von TemporalType enum ist :

  • TemporalType.DATE
  • TemporalType.TIME
  • TemporalType.TIMESTAMP

Einen ausführlichen Artikel über die Zuordnung von Datum und Uhrzeit mit JPA finden Sie hier.

3. In der Praxis

In der Praxis ist nach der korrekten Einrichtung unserer Entitäten nicht mehr viel zu tun, um sie mit Spring Data JPA abzufragen. Wir müssen nur die Abfragemethoden @Query Annotation verwenden.

Jeder Spring Data JPA-Mechanismus funktioniert einwandfrei .

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

3.1. Richten Sie eine Entität ein

Für den Anfang, lassen Sie uns sagen , dass wir einen haben Artikel Einheit, mit einem Veröffentlichungsdatum, eine Publikation Zeit und Erstellungsdatum und -uhrzeit:

@Entity public class Article { @Id @GeneratedValue Integer id; @Temporal(TemporalType.DATE) Date publicationDate; @Temporal(TemporalType.TIME) Date publicationTime; @Temporal(TemporalType.TIMESTAMP) Date creationDateTime; }

Zu Demonstrationszwecken teilen wir Veröffentlichungsdatum und -zeit in zwei Felder auf. Auf diese Weise werden die drei zeitlichen Typen dargestellt.

3.2. Fragen Sie die Entitäten ab

Nachdem unsere Entität eingerichtet ist, erstellen wir ein Spring Data- Repository , 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
  • und findAllWithCreationDateTimeBefore, mit dem Artikel abgerufen werden, die vor einem bestimmten Datum und einer bestimmten Uhrzeit erstellt wurden

Die beiden ersten Methoden basieren auf dem Mechanismus für Spring Data- Abfragemethoden und die letzte auf der Annotation @Query .

Am Ende ändert dies nichts an der Art und Weise, wie Daten behandelt werden. Die erste Methode berücksichtigt nur den Datumsteil des Parameters.

Die zweite berücksichtigt nur die Zeit der Parameter. Und der letzte wird sowohl Datum als auch Uhrzeit verwenden.

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, dass 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 wenig Theorie gelernt, bevor wir Spring Data-Mechanismen zum Abfragen der Entitäten verwendet haben. Wir haben gesehen, dass diese Mechanismen bei Datum und Uhrzeit genauso funktionieren wie bei anderen Datentypen.

Der Quellcode für diesen Artikel ist auf GitHub verfügbar.