Interroga entità per date e orari con Spring Data JPA

1. Introduzione

In questo breve tutorial, vedremo come eseguire query sulle entità per date con Spring Data JPA.

Per prima cosa aggiorneremo la nostra memoria su come mappare date e orari con JPA.

Quindi, creeremo un'entità con campi di data e ora e un repository Spring Data per interrogare tali entità.

2. Mappatura di date e orari con JPA

Per cominciare, esamineremo un po 'di teoria sulla mappatura delle date con JPA . La cosa da sapere è che dobbiamo decidere se vogliamo rappresentare:

  • Solo un appuntamento
  • Solo una volta
  • O entrambi

Oltre all'annotazione @Column (opzionale) , dovremo aggiungere l' annotazione @Temporal per specificare cosa rappresenta il campo.

Questa annotazione accetta un parametro che è un valore di TemporalType enum :

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

Un articolo dettagliato sulla mappatura di date e orari con JPA può essere trovato qui.

3. In pratica

In pratica, una volta configurate correttamente le nostre entità, non c'è molto lavoro da fare per interrogarle utilizzando Spring Data JPA. Dobbiamo solo usare metodi di query, annotazione @Query .

Ogni meccanismo JPA di Spring Data funzionerà perfettamente .

Vediamo un paio di esempi di entità interrogate da date e orari con Spring Data JPA.

3.1. Crea un'entità

Per i principianti, supponiamo di avere un'entità Articolo , con una data di pubblicazione, un'ora di pubblicazione e una data e ora di creazione:

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

Abbiamo diviso la data e l'ora di pubblicazione in due campi a scopo dimostrativo. In questo modo vengono rappresentati i tre tipi temporali.

3.2. Interroga le entità

Ora che la nostra entità è stata configurata, creiamo un repository Spring Data per interrogare quegli articoli.

Creeremo tre metodi, utilizzando diverse funzionalità JPA di Spring Data:

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); }

Quindi abbiamo definito tre metodi:

  • findAllByPublicationDate che recupera gli articoli pubblicati in una determinata data
  • findAllByPublicationTimeBetween che recupera gli articoli pubblicati tra due ore date
  • e findAllWithCreationDateTimeBefore che recupera gli articoli creati prima di una determinata data e ora

I primi due metodi si basano sul meccanismo dei metodi di query di Spring Data e l'ultimo sull'annotazione @Query .

Alla fine, ciò non cambia il modo in cui verranno trattate le date. Il primo metodo considererà solo la parte relativa alla data del parametro.

Il secondo considererà solo il tempo dei parametri. E l'ultimo utilizzerà sia la data che l'ora.

3.3. Prova le query

L'ultima cosa che dobbiamo fare è impostare alcuni test per verificare che queste query funzionino come previsto.

Per prima cosa importeremo alcuni dati nel nostro database e poi creeremo la classe di test che controllerà ogni metodo del repository:

@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)); } }

Ogni test verifica che vengano recuperati solo gli articoli che soddisfano le condizioni.

4. Conclusione

In questo breve articolo, abbiamo visto come eseguire query sulle entità utilizzando i campi di data e ora con Spring Data JPA.

Abbiamo imparato un po 'di teoria prima di utilizzare i meccanismi di Spring Data per interrogare le entità. Abbiamo visto questi meccanismi funzionare allo stesso modo con le date e le ore come fanno con altri tipi di dati.

Il codice sorgente di questo articolo è disponibile su GitHub.