Zoek entiteiten op datums en tijden met Spring Data JPA

1. Inleiding

In deze korte zelfstudie zullen we zien hoe u op datums kunt zoeken naar entiteiten met Spring Data JPA.

We zullen eerst ons geheugen opfrissen over het in kaart brengen van datums en tijden met JPA.

Vervolgens maken we een entiteit met datum- en tijdvelden en een Spring Data-repository om die entiteiten te doorzoeken.

2. Data en tijden in kaart brengen met JPA

Voor starters, we zullen een stukje theorie bespreken over het in kaart brengen van datums met JPA. Het ding om te weten is dat we moeten beslissen of we willen vertegenwoordigen:

  • Alleen een datum
  • Slechts een keer
  • Of allebei

Naast de (optioneel) @Kolom annotatie, moeten we de @Tijdelijk annotatie om te specificeren wat het veld vertegenwoordigt.

Deze annotatie heeft een parameter nodig die een waarde heeft van TemporalType enum:

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

Een gedetailleerd artikel over het in kaart brengen van datums en tijden met JPA vindt u hier.

3. In de praktijk

In de praktijk is er, als onze entiteiten eenmaal correct zijn opgezet, niet veel werk te doen om ze te bevragen met Spring Data JPA. We moeten gewoon gebruiken zoekmethoden, @Query annotatie.

Elk Spring Data JPA-mechanisme werkt prima.

Laten we een paar voorbeelden bekijken van entiteiten die op datums en tijden worden opgevraagd met Spring Data JPA.

3.1. Stel een entiteit in

Laten we om te beginnen zeggen dat we een Artikel entiteit, met een publicatiedatum, een publicatietijd en een aanmaakdatum en -tijd:

@Entity openbare klasse Artikel {@Id @GeneratedValue Geheel getal-id; @Temporal (TemporalType.DATE) Datum publicatieDatum; @Temporal (TemporalType.TIME) Datum publicatie Tijd; @Temporal (TemporalType.TIMESTAMP) Datum creationDateTime; }

We splitsen de publicatiedatum en -tijd op in twee velden voor demonstratiedoeleinden. Op die manier worden de drie tijdelijke typen weergegeven.

3.2. Vraag de entiteiten

Nu onze entiteit helemaal is opgezet, gaan we Spring Data maken repository om die artikelen te doorzoeken.

We zullen drie methoden maken, met behulp van verschillende Spring Data JPA-functies:

openbare interface ArticleRepository breidt JpaRepository uit {List findAllByPublicationDate (Date publishDate); Lijst findAllByPublicationTimeBetween (Datum publicatieTimeStart, Datum publicatieTimeEnd); @Query ("selecteer een artikel a waarin a.creationDateTime <=: creationDateTime") Lijst findAllWithCreationDateTimeBefore (@Param ("creationDateTime") Datum creationDateTime); }

Dus hebben we drie methoden gedefinieerd:

  • findAllByPublicationDate die artikelen ophaalt die op een bepaalde datum zijn gepubliceerd
  • findAllByPublicationTimeBetween die artikelen ophaalt die tussen twee opgegeven uren zijn gepubliceerd
  • en findAllWithCreationDateTimeBefore die artikelen ophaalt die vóór een bepaalde datum en tijd zijn gemaakt

De twee eerste methoden zijn gebaseerd op Spring Data query-methoden mechanisme en de laatste op @Query annotatie.

Dat verandert uiteindelijk niets aan de manier waarop datums worden behandeld. De eerste methode houdt alleen rekening met het datagedeelte van de parameter.

De tweede houdt alleen rekening met de tijd van de parameters. En de laatste gebruikt zowel datum als tijd.

3.3. Test de zoekopdrachten

Het laatste dat we moeten doen, is een aantal tests opzetten om te controleren of deze query's werken zoals verwacht.

We importeren eerst een paar gegevens in onze database en vervolgens maken we de testklasse die elke methode van de repository controleert:

@RunWith (SpringRunner.class) @DataJpaTest openbare klasse ArticleRepositoryIntegrationTest {@Autowired privé ArticleRepository-repository; @Test openbare ongeldigheid whenFindByPublicationDate_thenArticles1And2Returned () {Lijstresultaat = repository.findAllByPublicationDate (nieuwe SimpleDateFormat ("jjjj-MM-dd"). Parse ("2018-01-01")); assertEquals (2, result.size ()); assertTrue (result.stream () .map (Artikel :: 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 ("16: ("). 30 ")); assertEquals (2, result.size ()); assertTrue (result.stream () .map (Artikel :: getId) .allMatch (id -> Arrays.asList (2, 3) .contains (id))); } @Test openbare ongeldige gegevenArticlesWhenFindWithCreationDateThenArticles2And3Returned () {Lijstresultaat = repository.findAllWithCreationDateTimeBefore (nieuwe SimpleDateFormat ("yyyy-MM-dd HH: mm"). Parse ("2017-12-15 10:00")); assertEquals (2, result.size ()); assertTrue (result.stream () .map (Artikel :: getId) .allMatch (id -> Arrays.asList (2, 3) .contains (id));}}

Elke test verifieert dat alleen de artikelen die aan de voorwaarden voldoen, worden opgehaald.

4. Conclusie

In dit korte artikel hebben we gezien hoe entiteiten kunnen worden opgevraagd met behulp van hun datum- en tijdvelden met Spring Data JPA.

We hebben een beetje theorie geleerd voordat we Spring Data-mechanismen gebruikten om de entiteiten te bevragen. We zagen dat die mechanismen op dezelfde manier werken met datums en tijden als met andere soorten gegevens.

De broncode voor dit artikel is beschikbaar op GitHub.