Entités de requête par dates et heures avec JPA de données de printemps

Interroger des entités par dates et heures avec Spring Data JPA

1. introduction

Dans ce rapide didacticiel, nous allons voir comment interroger des entités par date avec Spring Data JPA.

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

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

2. Cartographie des dates et des heures avec JPA

Pour commencer,we’ll review a bit of theory about mapping dates with JPA. La chose à savoir 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 deTemporalType enum:

TemporalType.DATE
TemporalType.TIME
TemporalType.TIMESTAMP

Un article détaillé sur le mappage des dates et heures avec JPA peut être trouvéhere.

3. En pratique

En pratique, une fois que nos entités sont correctement configurées, il n’ya pas beaucoup de travail à faire pour les interroger à l’aide de JPA Spring Data. Nous devons juste utiliser la sannotationquery methods, @Query .

Every Spring Data JPA mechanism will work just fine.

Voyons quelques exemples d'entités interrogées par date et heure 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 une 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 entièrement configurée, créons un Spring Datarepository 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
findAllByPublicationTimeBetween qui récupère les articles publiés entre deux heures données
etfindAllWithCreationDateTimeBefore 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 Spring Dataquery methods 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. The first method will only consider the date part of the parameter.

La seconde 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 configurer 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 correspondant 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 constaté que ces mécanismes fonctionnent de la même manière avec les dates et les heures que pour les autres types de données.

Le code source de cet article est disponibleover on GitHub.

TOC