Interroger les entités par date et heure avec Spring Data JPA

1. Introduction

Dans ce tutoriel rapide, nous verrons comment interroger des entités par date avec Spring Data JPA.

Nous allons d'abord rafraîchir notre mémoire sur la façon de mapper les dates et les heures avec JPA.

Ensuite, nous créerons une entité avec des champs de date et d'heure ainsi qu'un référentiel Spring Data pour interroger ces entités.

2. Mappage des dates et heures avec JPA

Pour commencer, nous allons passer en revue un peu de théorie sur la cartographie des dates avec JPA . Ce qu'il faut savoir, c'est que nous devons décider si nous voulons représenter:

  • Une date seulement
  • Un temps seulement
  • Ou les deux

En plus de l' annotation (facultative) @Column , nous devrons ajouter l' annotation @Temporal pour spécifier ce que le champ représente.

Cette annotation prend un paramètre qui est une valeur de TemporalType enum :

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

Un article détaillé sur la cartographie des dates et des heures avec JPA est disponible ici.

3. En pratique

En pratique, une fois nos entités correctement configurées, il n'y a pas beaucoup de travail à faire pour les interroger à l'aide de Spring Data JPA. Nous devons simplement utiliser des méthodes de requête, l' annotation @Query .

Chaque mécanisme Spring Data JPA fonctionnera parfaitement .

Voyons quelques exemples d'entités interrogées par dates et heures avec Spring Data JPA.

3.1. Configurer une entité

Pour commencer, disons que nous avons une entité Article , avec une date de publication, une heure de publication et une date et heure de création:

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

Nous avons divisé la date et l'heure de publication en deux champs à des fins de démonstration. De cette façon, les trois types temporels sont représentés.

3.2. Interroger les entités

Maintenant que notre entité est configurée, créons un référentiel Spring Data pour interroger ces articles.

Nous allons créer trois méthodes, en utilisant plusieurs fonctionnalités Spring Data JPA:

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

Nous avons donc défini trois méthodes:

  • findAllByPublicationDate qui récupère les articles publiés à une date donnée
  • findAllByPublicationTimeB between qui récupère les articles publiés entre deux heures données
  • et findAllWithCreationDateTimeBefore qui récupère les articles créés avant une date et une heure données

Les deux premières méthodes reposent sur le mécanisme des méthodes de requête Spring Data et la dernière sur l' annotation @Query .

En fin de compte, cela ne change pas la façon dont les dates seront traitées. La première méthode ne prendra en compte que la partie date du paramètre.

Le second ne considérera que le temps des paramètres. Et le dernier utilisera à la fois la date et l'heure.

3.3. Tester les requêtes

La dernière chose que nous devons faire est de mettre en place des tests pour vérifier que ces requêtes fonctionnent comme prévu.

Nous allons d'abord importer quelques données dans notre base de données, puis nous créerons la classe de test qui vérifiera chaque méthode du référentiel:

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

Chaque test vérifie que seuls les articles répondant aux conditions sont récupérés.

4. Conclusion

Dans ce court article, nous avons vu comment interroger des entités à l'aide de leurs champs de date et d'heure avec Spring Data JPA.

Nous avons appris un peu de théorie avant d'utiliser les mécanismes Spring Data pour interroger les entités. Nous avons vu que ces mécanismes fonctionnent de la même manière avec les dates et les heures qu'avec d'autres types de données.

Le code source de cet article est disponible à l'adresse over sur GitHub.